As400 Tutoriel CL PDF

AS/400
Casablanca Maroc Email : oits.maroc@gmail.com Tel: 061425929

Ce document est la propriété d’open IT Service , il ne peut être utilisé, reproduit ou communiqué Sans son autorisation
Janvier2012 v12 -Cap.- AS/400 Page 1

Table des matières
Le hardware de l'AS/400 ....................................................................................................... 5

L'AS/400 dans la gamme IBM .................................................................................. 5
Carte d'identité de l'AS/400 ....................................................................................... 8
L'architecture hardware ............................................................................................. 10
Le système d'exploitation OS/400 ......................................................................................... 16
Généralités ................................................................................................................. 16
Le multitâche ............................................................................................................. 17
Le langage CL ........................................................................................................... 18
Le SGBD relationnel est intégré................................................................................ 18
Le moniteur de télétraitement est intégré .................................................................. 19
Les programmes utilitaires de l'OS/400 .................................................................... 19
Les logiciels AS/400 du marché ................................................................................ 23
L'organisation de l'espace disque............................................................................... 24
Travaux batch et interactifs ....................................................................................... 27
JOBQ et OUTQ ......................................................................................................... 29
Débuter sur l'AS/400 ............................................................................................................. 31
Ouvrir une session ..................................................................................................... 31
Les menus et les commandes .................................................................................... 32
Fermer une session .................................................................................................... 37
Créer une bibliothèque .............................................................................................. 38
Créer un fichier source .............................................................................................. 39
Saisir un membre source ........................................................................................... 39
Compiler un programme............................................................................................ 40
Gérer les fichiers d'impression .................................................................................. 41
Exécuter un programme............................................................................................. 42
Le langage GAP .................................................................................................................... 43
Généralités sur le GAP .............................................................................................. 43
La structure du langage.............................................................................................. 44
Les spécifications F ................................................................................................... 49
Les spécifications C ................................................................................................... 50
Les ordres de calcul et de transfert ............................................................................ 51
L'ordre de lecture séquentielle ................................................................................... 56
Les ordres de structure............................................................................................... 58
Les sous-programmes ................................................................................................ 68
Les ordres d'entrée-sortie .......................................................................................... 72
Les SDD des fichiers d'impression........................................................................................ 80
Le principe des SDD ................................................................................................. 80
La syntaxe des SDD d'impression ............................................................................. 80
Mettre en oeuvre des SDD......................................................................................... 91

Les SDD de fichiers de données............................................................................................ 93
Les trois parties d'un fichier physique de données .................................................... 93
Pour créer un nouveau fichier physique... ................................................................. 98
Les SDD des fichiers physiques ................................................................................ 100
Les deux parties d'un fichier logique ......................................................................... 106
Les SDD des fichiers logiques .................................................................................. 108
Des fichiers logiques particuliers .............................................................................. 114
Les SDD de fichiers écran ..................................................................................................... 119
Présentation générale ................................................................................................. 119
Constantes et variables .............................................................................................. 120
Les touches de fonction ............................................................................................. 123
Les attributs d'affichage ............................................................................................. 125
Les codes d'édition .................................................................................................... 129
Conditionnement par indicateurs ............................................................................... 131
Gestion des messages d'erreur ................................................................................... 132
Autres possibilités ..................................................................................................... 134
Utiliser les fichiers écran en GAP ............................................................................. 136
Les sous-fichiers .................................................................................................................... 138
Le but des sous-fichiers ............................................................................................. 138
Le principe des sous-fichiers ..................................................................................... 142
Les SDD d'un sous-fichier ......................................................................................... 146
Utiliser un sous-fichier dans un programme GAP..................................................... 152
Mise à jour d'un sous-fichier par l'utilisateur ............................................................ 155
Mise à jour d'un sous-fichier par le programme ........................................................ 158
L'OVERLAY dans les sous-fichiers .......................................................................... 159
Sous-fichier de saisie ................................................................................................. 160
Les Tableaux ......................................................................................................................... 161
De l'utilité des tableaux ............................................................................................. 161
La déclaration d'un tableau ........................................................................................ 162
Le chargement d'un tableau ....................................................................................... 162
La recherche d'informations dans le tableau.............................................................. 166
Le "débuggage" des programmes .......................................................................................... 169
Les points d'arrêt........................................................................................................ 169
La fonction "trace"..................................................................................................... 171
Trucs et astuces ..................................................................................................................... 172
L'appel système ......................................................................................................... 172
Modifier sa file d'attente de messages ....................................................................... 176
Imprimer son nom sur les listings ............................................................................. 176
Contrôle des zones de saisie ...................................................................................... 177
Verrouillage d'enregistrements .................................................................................. 178

Avant propos
Ce livre va vous servir de guide sur le chemin des "moyens-systèmes" IBM

AS/400.
Et, si l'on prend un guide en montagne, on commence par se mettre d'accord sur le
point de départ mais aussi sur le point d'arrivée.
Alors, d'où partons-nous, c'est-à-dire où en êtes-vous en informatique ?

Connaissez-vous le minimum requis pour vous attaquer à l'AS/400 ?
Les prérequis
Pour tirer profit au maximum de ce livre, il est nécessaire que vous ayez au départ
les connaissances suivantes :
- connaître le principe général de fonctionnement des ordinateurs;
- savoir à quoi sert un système d'exploitation;
- savoir ce qu'est un fichier, un enregistrement, une rubrique, un octet, un bit;
- savoir écrire un petit programme, peu importe le langage.

Les objectifs
Et maintenant, où allons-nous ensemble ?
Lorsque vous aurez exploité ce livre, vous devriez avoir atteint les objectifs
suivants :
- connaître l'architecture hardware de l'AS/400;
- connaître le principe de fonctionnement du système d'exploitation de l'AS/400;
- savoir rédiger un programme GAP simple;
- savoir saisir, compiler, exécuter un programme;
- savoir créer des fichiers.
Ce livre ne prétend en aucun cas aborder toutes les possibilités de l'AS/400, car
IBM le fait très bien, en anglais malheureusement, et dans une centaine de
brochures aussi complètes que détaillées. Il contient quelques exercices dont tous
les corrigés sont regroupés en annexe 5.
En résumé, ce livre doit permettre à une personne déjà initiée à la

programmation de créer des petits programmes GAP sur un AS/400.
Le point de départ et le point d'arrivée de notre périple vous conviennent-ils ?
Vous êtes toujours là ?
Vous avez répondu "oui" ? Alors on commence.

1. Le hardware de l'AS/400
1.1. L'AS/400 dans la gamme IBM
Situons d'abord l'AS/400 parmi ses confrères.
IBM, comme la plupart des grands constructeurs informatiques, est présent dans
les 3 gammes classiques d'ordinateurs :
- les micro-ordinateurs,
- les moyens systèmes, encore appelés mini-ordinateurs,
- les gros systèmes, appelés aussi "main-frames".
1.1.1. Les micro-ordinateurs IBM

1980 : les débuts de la micro-informatique.
Les premiers constructeurs de micro-ordinateurs s'appellent APPLE,

COMMODORE, R2E, VICTOR, TANDY...
Leurs machines ne sont pas compatibles entre elles, c'est-à-dire que les systèmes
d'exploitation sont différents, les langages aussi. L'échange de données entre
machines est quasi impossible.
Les machines les plus puissantes ont 32 000 octets (ou caractères) en mémoire !
Si vous avez vécu cette époque, n'en parlez surtout pas à vos enfants, c'est ce que
l'on trouve dans la moindre calculette programmable d'aujourd'hui !
C'est donc en 1981 qu'IBM lance son fameux PC. L'étiquette IBM rassure les
acheteurs qui étaient un peu perdus dans la jungle des autres marques.
L'IBM PC devient peu à peu la norme, et les autres constructeurs s'y rallient un à
un en fabriquant ce que l'on a appelé des compatibles PC.
Aujourd'hui, pratiquement toute la micro-informatique professionnelle est

compatible PC, sauf un constructeur (tiens, ça me rappelle un petit village
gaulois!), APPLE avec ses Macintosh.

Petit à petit, d'année en année, ou plutôt de mois en mois, les PC (ceux d'IBM et
des autres) se sont musclés.
Leur processeur était au départ capable de traiter 8 informations (ou bits) à la fois,
c'est le processeur INTEL 8086.
Puis il devient capable de traiter 16 bits, c'est le processeur INTEL 80286.

En 1988 apparaît le processeur INTEL 80386, qui traite 32 bits à la fois. Puis sa
version améliorée, le 80486.
Dans le même temps, ces machines ont acquis un disque dur de 5 millions
d'octets, puis de 10 millions, puis de 20 millions puis 40, ou 80 mégaoctets, et
aujourd'hui couramment 200 millions d'octets.
La concurrence devenant rude, et le PC quelque peu dépassé, IBM sort quelques

années après, un nouveau micro-ordinateur, appelé le PS/2.
Son architecture n'est pas compatible avec l'ancien PC. Le "bus", véritable
colonne vertébrale d'un ordinateur, a été transformé. L'ancien bus, nommé ISA,
est remplacé par le bus MCA (Micro Channel Architecture). Ce sont
essentiellement les grandes entreprises qui se sont équipées de PS/2.
Et, pour en terminer avec la micro-informatique IBM, signalons l'IBM PS/1 sorti
fin 1989 qui est un retour à l'architecture ISA et donc au compatible PC.
Vous pensez peut-être que je me suis un peu trop étendu sur la micro-informatique
dans un ouvrage dédié à la mini-informatique. C'est en fait que ces deux types
d'informatique ne peuvent plus s'ignorer, ou pis se mépriser. Elles vont
s'interpénétrer de plus en plus. Mais j'y reviendrai après vous avoir parlé de la
gamme des moyens systèmes d'IBM.
1.1.2. Les moyens systèmes IBM
Ici commence un domaine moins connu du grand public. Puisque cela concerne
l'informatisation des PME, et parfois de certaines grosses entreprises.
IBM sort vers la fin des années 60, l'IBM 3, à cartes perforées.
Celui-ci évolue au début des années 70 vers l'IBM 32, puis l'IBM 34 à la fin des
années 70, suivi par l'IBM 36, au début des années 80.
Dans cette évolution, on passe des machines à cartes perforées aux machines à
disquettes et enfin à disques fixes.
Puis un événement important, très peu de temps après la sortie du 34 (le 36 sortira
en 1983, comme suucesseur du 34), c'est l'arrivée de l'IBM 38, très attendu et

depuis plusieurs années dans les cartons d'IBM. Cette machine se veut
conceptuellement en avance sur son temps, et elle l'est réellement.
La différence de puissance entre IBM 36 et IBM 38 est telle que le 36 convient

aux petites PME (il s'essouffle au-delà de 20 terminaux), alors que le 38 s'adapte
parfaitement aux grosses PME (jusqu'à 100 terminaux).
Le 21 juin 1988, IBM annonce une nouvelle machine, l'IBM AS/400. Ce n'est pas
en fait réellement une nouvelle machine. Il est vrai que les composants hardware
sont d'une nouvelle génération, ils sont plus compacts, chauffent moins, vont plus
loin en terme de puissance de traitement de l'information.
Quelques innovations tout de même. Mais l'essentiel des principes de l'IBM 38 est
conservé. C'est-à-dire qu'hormis le niveau hardware l'AS/400 est à 90%
ressemblant à l'IBM 38. C'est tant mieux pour les PME qui n'ont pas eu, une fois
de plus, à faire un bond technologique, mais c'est un peu dommage pour le progrès
de la mini-informatique.
Aujourd'hui l'AS/400 se vend très bien : le Gartner Group estime en avril 1991
que le parc installé serait déjà 110 000 AS/400 de par le monde, sur un total de
500 000 mini-IBM en service (IBM 36 + IBM 38 + AS/400).
En France, selon des sources proches d'IBM, on en serait à 5 000 AS/400 sur un
total de 22 000 mini-IBM en service.
On peut imaginer que les 390 000 IBM 36 et 38 qui tournent encore aujourd'hui
risquent fort d'être remplacés par des AS/400 dans les années qui viennent.
1.1.3. Les gros systèmes IBM
Ce sont ces ordinateurs qui équipent les grosses entreprises. Il n'est pas rare de
leur voir connectés des milliers de terminaux dispersés sur le territoire national,
voire transnational.
Dans cette gamme des gros systèmes, l'ancêtre de base est l'IBM 360 des années
60. Il a évolué en IBM 370 dans les années 70, mais aujourd'hui, on retrouve
toujours la même philosophie incarnée par des machines évidemment plus
puissantes :
- l'IBM 43xx;
- l'IBM 309x;
Les IBM 43xx étant nettement plus puissants que les IBM 309x. Ce sont des
machines que l'on ne trouve que dans de très grosses entreprises. Les lettres "x"
sont à remplacer par le numéro exact du modèle. Par exemple, dans la série des

43xx, on trouve l'IBM 4381. Les systèmes d'exploitation de ces machines sont
essentiellement VM et MVS.
Voilà rapidement brossé le panorama des "main frames" IBM. Mais on ne peut
passer sous silence deux machines qui sortent de la typologie micro-mini-gros
systèmes.
L'IBM 9370
Encore un autre modèle d'ordinateur IBM, c'est l'intermédiaire entre un moyen et

un gros système. Il permet les applications de gestion, mais aussi des applications
qui relèvent plus de l'informatique industrielle, puisqu'on peut lui connecter des
machines de fabrication.
Le RS/6000
Sorti récemment chez IBM, il se situe plutôt dans la gamme mini. Il a la

particularité de fonctionner sous AIX qui est la version IBM du fameux système
d'exploitation UNIX.
Et maintenant que nous avons fait le tour de la gamme IBM, recentrons-nous sur
notre cher AS/400.
1.2. Carte d'identité de l'AS/400
Nom : IBM
Prénom : AS/400
Date de naissance : 21 JUIN 1988
Lieu de naissance : USA
Complétons cette carte d'identité par la description des différents modèles

d'AS/400 de la gamme. Nous allons les regrouper d'après la taille de leur...
carrosserie, appelée "System Unit" en anglais. Il y a en effet 3 tailles possibles de
boîtiers.

1.2.1. Le boîtier 9402
Ce boîtier, de la taille d'un gros micro, peut contenir l'un des trois modèles
suivants.
L'AS/Entry rebaptisé Y10 : en bas de gamme, on trouve cette machine qui est en
réalité un IBM 36 construit avec les composants hardware de l'AS/400. Mais il
fonctionne bel et bien comme un IBM 36, et non un AS/400. IBM a tenu à le
conserver car c'est une machine qui convient parfaitement aux petites PME qui
n'ont que quelques postes de travail.
Les modèles D04 et D06 : ce sont, eux, de vrais petits AS/400, leurs prix
commencent aux alentours de 100 000 F.
Légèrement plus volumineux, mais tenant toujours sous un bureau, il abrite le

modèle D10 ou le D20 ou le D25 qui sont des ordinateurs de puissance moyenne.
Un modèle D20 vaut environ 500 000 F et supporte aisément 20 terminaux.
Attention cependant aux estimations de puissance sous forme de nombre de
terminaux supportés.
En effet, 20 terminaux utilisés toute la journée pour de la saisie intensive

"pomperont" autant les ressources mémoire et le disque de l'ordinateur que 100
terminaux utilisés quelques minutes par heure. En fait, le plus gros "dévoreur"
d'énergie informatique sur un système comme l'AS/400, c'est... vous-même : le
DEVELOPPEUR D'APPLICATIONS.
Il saisit ses programmes, les compile, les teste, et comme il arrive parfois qu'un
programme boucle, la machine se porte beaucoup mieux quand il est malade ou en
vacances. Mais, poursuivons notre ascension dans la gamme.

Il est de la taille d'une ou plusieurs armoires à glaces. Tout dépend du nombre
d'organes périphériques d'entrée-sortie installés (disques, bandes, contrôleurs de
lignes de télécommunications...).
Il peut contenir les modèles D35, D45, D50,D60, D70, D80. Le haut de gamme, le
D80, coûte la bagatelle de 10 millions de francs et offre la possibilité à 600
utilisateurs de travailler simultanément ! C'est un biprocesseur. C'est-à-dire que
l'ensemble du travail à effectuer par l'ordinateur est réparti entre 2 processeurs.
Sachez qu'IBM étudie actuellement une machine dotée de 6 processeurs.

Peut-on encore parler de "mini-ordinateur" ?

1.3. L'architecture hardware
Tous les ordinateurs ont la même architecture, de la plus petite calculatrice

programmable aux gigantesques CRAY. L'AS/400 n'échappe pas à la règle, il
comprend donc les éléments suivants :
- un organe de traitement;
- des organes de stockage;
- des organes d'entrée et de sortie.
Reprenons chacun de ces organes :
1.3.1. L'organe de traitement
L'organe de traitement s'appelle comme d'habitude le processeur. C'est un

processeur à 32 bits, qui peut gérer des adresses d'une longueur allant jusqu'à 64
bits. Possibilité comme nous venons de le voir d'avoir 2 processeurs, sur le modèle
D80. Dans ce cas, la répartition du travail entre les deux processeurs est
totalement invisible pour l'utilisateur et même pour le programmeur.
1.3.2. Les organes de stockage

Les organes de stockage sont les suivants :
La mémoire centrale
Appelée encore mémoire RAM ou mémoire vive, elle peut aller de 4 Mo à plus de
192 Mo sur les gros modèles.
Le (ou les) disque(s) magnétique(s) fixe(s)
C'est l'équivalent des disques durs sur micro-ordinateurs. Différentes capacités

sont disponibles :

320 Mo, 640 Mo ou 800 Mo par disque dans une machine de la gamme 9404.
200 Mo, 400 Mo, 600 Mo, 855 Mo, 942 Mo ou 1742 Mo dans la gamme 9406
Le maximum est de 3,8 Go sur les modèles 9404, et de 56 Go sur les 9406
(1 Go = 1 gigaoctet = 1 milliard d'octets).
Le lecteur de disquettes éventuel
Il n'est pas obligatoire, mais il est bien utile pour effectuer des échanges de
données entre deux AS/400 qui ne sont pas reliés par une ligne de
télécommunication. Il sert aussi parfois pour des petites sauvegardes.
Deux modèles existent : le modèle pour grandes disquettes 8 pouces, et le modèle
pour petites disquettes 5 pouces 1/4.
Les disquettes AS/400 sont compatibles avec les disquettes IBM 36 et IBM 38,
mais restent absolument incompatibles avec les disquettes 5 pouces 1/4 pour PC !
La capacité réduite (1,2 Mo sur les deux modèles) interdit d'y sauvegarder de gros
fichiers.
Le lecteur-enregistreur de bandes magnétiques en cartouches
Il n'est pas obligatoire non plus, mais c'est le moyen le plus adapté pour faire les
sauvegardes des disques. Il s'agit de cassettes magnétiques de 1/2 ou 1/4 de pouce
de large, ressemblant un peu aux vidéocassettes. La capacité d'une cartouche va de
120 Mo à 2,3 Go.
Le lecteur-enregistreur de bandes magnétiques en bobines
Assez rare sur AS/400, cet appareil écrit et lit des bandes magnétiques de 1/2
pouce de large, non pas sous forme de cassettes, mais sous forme plus classique de
bobines de 30 centimètres de diamètre environ.

1.3.3. Les organes d'entrée et de sortie
Les terminaux
Les postes de travail de l'AS/400 sont des terminaux, on les appelle encore
"terminaux passifs" ou plus méchamment : "terminaux bêtes". En fait un terminal
n'est qu'un écran de visualisation associé à un clavier, le tout étant relié à l'AS/400
par un câble de liaison. Le terminal n'a aucune intelligence propre: il n'a ni
processeur, ni mémoire, ni disque.
On distingue différents types de terminaux, mais tous sont de la même famille,

c'est la famille des terminaux "5250" compatibles avec toute le gamme des
moyens systèmes IBM : IBM 34, 36, 38 et AS/400. Attention : les terminaux des
gros systèmes IBM sont d'un modèle différent et incompatible, ils appartiennent à
une autre famille, celle des terminaux "3270".
Il existe une bonne vingtaine de modèles de terminaux "5250", qui diffèrent les
uns des autres par les caractéristiques suivantes :
- couleur ou monochrome;
- alphabet classique, japonais, coréen, chinois...;
- affichage de 24 lignes de 80 caractères ou 27 lignes de 132 caractères;
- connexion par câble "twinax" ou par liaison ASCII;
- ergonomie du clavier et de l'écran.
De plus, certains écrans permettent d'ouvrir plusieurs sessions simultanées. Sur un

terminal bi-sessions, on peut avoir simultanément deux sessions en cours. Par
exemple l'employé du service commercial d'une entreprise est en train
d'enregistrer un bon de commande sur son terminal. Le téléphone sonne. C'est un
client qui voudrait savoir si tel article est disponible en stock actuellement.
L'employé peut ouvrir une deuxième session pour interroger son stock, sans pour
autant interrompre la première session de saisie des commandes. Puis il passera de
l'une à l'autre des deux sessions en appuyant sur une simple touche. De son côté,
l'ordinateur aura l'impression d'avoir deux terminaux distincts en ligne, avec deux
programmes en cours d'exécution.
Les micro-ordinateurs en émulation de terminaux
En lieu et place de n'importe quel terminal, on peut connecter à l'AS/400 un

micro-ordinateur qui va simuler un terminal. Ce micro utilisera son "intelligence"
pour faire croire à l'AS/400 qu'il est bête. C'est en fait exactement cela ! On ajoute
une carte électronique spéciale d'extension sur le micro, puis on branche le câble
de l'AS/400 sur cette carte, et on lance un logiciel spécial d'émulation de terminal.

Le logiciel d'émulation combiné à la carte d'extension font que le micro envoie à
l'AS/400 exactement les mêmes signaux électriques que ceux qu'enverrait un
simple terminal. L'AS/400 est donc totalement incapable réaliser qu'il converse
avec un micro. Et lorsque le micro reçoit des impulsions électriques qui
proviennent de l'AS/400, il les décode et affiche à l'écran exactement ce
qu'afficherait un terminal.
Les imprimantes
Sur un AS/400, on peut connecter plusieurs imprimantes. D'abord, on peut

connecter une imprimante directement sur l'unité centrale. Ce sera en général une
imprimante rapide. Mais en plus, on pourra connecter plusieurs imprimantes sur le
réseau de terminaux, c'est-à-dire n'importe où dans l'entreprise sur une simple
prise pour terminal. En fait, pour être clair, sur toute prise pour terminal de
l'AS/400, on peut connecter ou bien un terminal, ou bien une imprimante.
Le câblage du réseau de terminaux
Après avoir passé en revue les composantes d'un AS/400, examinons maintenant
comment sont reliés les terminaux à l'unité centrale. Il existe sur l'AS/400
différents types de câblages :
- en liaison locale directe;
- en liaison à un réseau local de micro-ordinateurs;
- en liaison par ligne téléphonique normale ou louée;
- en liaison par des réseaux publics tels que le réseau TRANSPAC;
- en liaison par ligne directe pour les terminaux ASCII.
Détaillons les deux premiers types de liaison.
La liaison locale directe
C'est de loin la plus usitée. Le câble le plus souvent utilisé est le câble "twinax".
La longueur du câble reliant le terminal à l'AS/400 ne doit pas dépasser 1 525
mètres, ce qui est largement suffisant dans une PME. Le câble "twinax" est
composé de deux conducteurs électriques isolés et torsadés, le tout entouré d'une
tresse métallique appelée blindage.

La topologie du réseau est la suivante :
- de l'AS/400 sortent un certain nombre de prises pour ligne "twinax";
- sur chacune de ces prises, on peut brancher un et un seul câble "twinax"de 1 525
mètres maxi;
- tout au long de ce câble "twinax" on peut brancher de 1 à 7 terminaux maximum.
Rappelons qu'un terminal peut être aussi bien un écran qu'une imprimante.
Comment sont identifiées chacune des lignes, et chacun des terminaux sur une
ligne ?
Les connecteurs des lignes "twinax" sur l'AS/400 sont numérotés de 0 à N.

Et chaque terminal a son adresse propre sur le câble "twinax" qui le relie à l'unité
centrale. Cette adresse est comprise entre 0 et 6, puisque l'on peut avoir au
maximum 7 terminaux sur un câble.
L'adresse du terminal doit être impérativement configurée correctement sur le
terminal à l'aide de petits interrupteurs, que l'on appelle "switch". Les terminaux
les plus récents ont leur adresse configurable non pas par "switch", mais par les
touches du clavier. L'adresse sera alors mémorisée dans un petit circuit CMOS
alimenté par une batterie au cadmium-nickel.
Sur le dernier terminal, situé à l'extrémité de chaque câble "twinax", il faut

positionner un autre interrupteur appelé le "terminator". Cet interrupteur possède 2
positions repérées 1 et 2. La position 1 est à choisir s'il s'agit du dernier terminal
du câble, la position 2, dans le cas contraire.
Liaison à un réseau local de micro-ordinateurs
Un réseau local de micro-ordinateurs ou LAN (qui signifie Local Area Network),

est un ensemble de micro-ordinateurs reliés entre eux par un système de câblage
qui ne dépasse généralement pas les limites d'un immeuble. Actuellement deux
systèmes de réseaux locaux sont prépondérants sur le marché, ce sont les réseaux :
- "Token Ring" d'IBM à topologie en anneau;

- "Ethernet" à topologie en bus.
On peut désormais connecter l'un ou l'autre de ces 2 sortes de réseaux à un

AS/400. Les micro-ordinateurs devront alors fonctionner en mode émulation de
terminal, comme expliqué plus haut. Cette solution est particulièrement
avantageuse, aussi bien financièrement que fonctionnellement.

Financièrement, le coût d'un micro-ordinateur est aujourd'hui légèrement inférieur
à celui d'un terminal, quand au câblage le coût est lui aussi moindre par rapport au
coût d'un câblage classique "twinax".
Fonctionnellement, on a tout à y gagner, puisque le même poste de travail donne

accès à l'AS/400, mais aussi à la multitude des logiciels micro disponibles sur le
marché. De plus, dans ce contexte, l'AS/400 peut abriter dans ses disques des
fichiers et des logiciels MSDOS ou OS/2, et servir ainsi de serveur pour les
micros du réseau. Ce n'est pas le moindre des avantages de ce système de câblage!
1.3.4. Autres connexions possibles
Un des arguments publicitaires d'IBM est de dire que l'AS/400 est une machine
particulièrement "communicante". Et c'est vrai : on peut connecter à l'AS/400
toutes sortes d'ordinateurs (surtout des IBM !), et cela de différentes manières.
Mais nous ne rentrerons pas dans les détails assez compliqués de ces connexions...

2. Le système d'exploitation
OS/400
2.1. Généralités
Le système d'exploitation de l'AS/400 s'appelle l'OS/400 (OS= Operating

System). C'est le même sur tous les modèles d'AS/400 du plus petit au plus gros
(sauf sur l'AS/ENTRY). C'est un énorme avantage, car pour passer au modèle
supérieur, il suffit de recopier les disques de l'ancienne machine sur ceux de la
nouvelle, et il n'y aura rien à reprogrammer.
Listons les fonctions principales de l'OS/400. C'est le système d'exploitation qui

gère :
- les travaux en cours;

- la simultanéité apparente de l'exécution des différents programmes qui se
déroulent à un moment donné dans l'ordinateur;
- l'accès à tous les organes d'entrée et de sortie;
- le rangement des informations sur les organes de stockage magnétique;
- les sécurités qui protégent contre les pertes de données dues à des pannes
éventuelles ou bien encore contre les indiscrétions;
- le gestion des impressions sur papier;
- et beaucoup d'autres choses encore...
Sur micro compatible PC, on a le choix entre les systèmes d'exploitation suivants:
MSDOS, UNIX, PROLOGUE... Sur gros systèmes IBM, les principaux systèmes
d'exploitation sont DOS/VS, MVS, VM. Sur BULL, on trouvera GCOS et UNIX.
Sur DIGITAL, nous avons VMS. Et sur l'AS/400, on n'a pas le choix ! C'est
obligatoirement l'OS/400 qui va régir la machine. C'est un système d'exploitation
extrêmement complet, je dirais presque trop complet, tant l'éventail de ses
possibilités a été poussé loin. Rendez-vous compte : le système MSDOS tient sur
une disquette de 360 Ko, UNIX occupe 30 Mo, et l'OS/400 ? 300 millions
d'octets !
L'OS/400 a connu différents versions, comme tout logiciel. Nous en sommes
actuellement à la version 2.1.0 : ce qui signifie "version 2, release 1, numéro de
modification 0". Et nous avons connu précédemment les versions 1.1 , 1.2 , 1.3 ,
et 2.0 .
Détaillons les grandes fonctionnalités de l'OS/400.

2.2. Le multitâche
L'OS/400 est un système d'exploitation multitâche, c'est-à-dire que plusieurs

tâches (ou programmes) pourront se dérouler en même temps dans l'unité centrale.
Notons que si cela peut être considéré comme un luxe pour une machine mono-
poste de travail, c'est absolument indispensable sur un ordinateur multiposte
comme l'AS/400. Sinon à quoi cela servirait-il d'avoir plusieurs terminaux, s'il n'y
avait qu'un seul de ces terminaux qui puisse travailler à la fois ?
Or le processeur ne peut, lui, exécuter qu'un ordre à la fois. Grave problème !

L'animateur d'un débat politique à la télévision a exactement le même problème
lorsque tous les participants veulent s'exprimer au micro en même temps. Il alloue
donc un temps de parole équitable à chacun des orateurs, ainsi chacun parle à tour
de rôle. De la même façon, un système d'exploitation multitâche va allouer le
processeur quelques instants à tour de rôle à chacune des tâches.
Quelques différences toutefois avec le débat politique, et heureusement !

Le système d'exploitation alloue des tranches de temps extrêmement courtes, de
l'ordre de la milliseconde, si bien que l'utilisateur, sur son terminal, ne se rend
même pas compte du "tour de table permanent" qui se passe dans le processeur. Il
perçoit tout de même que plus le nombre de tâches en cours est grand, plus la
machine semble peiner, c'est inévitable.
Autre différence, si l'animateur de débat doit être équitable dans son partage du
temps de parole, l'ordinateur, lui, peut ne pas l'être. Ce sera le cas si, par exemple,
on a attribué à l'une ou à l'autre des tâches une priorité d'exécution plus faible.
Autre différence encore, si l'une des tâches est occupée à faire une lecture sur
disque, ou toute autre action extrêmement longue par rapport à la vitesse du
processeur, cette tâche passera alors son tour. Elle cédera son temps de processeur
à une autre tâche, tout comme un participant à notre débat politique pourrait céder
son temps de parole s'il sort quelques instants pour chercher un dossier.

2.3. Le langage CL
Pour contrôler ce système d'exploitation, on dispose du langage CL, ce qui

signifie "Control Language". Ce langage très complet dispose de la bagatelle de
900 ordres !
2.4. Le SGBD relationnel est intégré
Mais d'abord rappelons ce qu'est un SGBD. On appelle "base de données" un

ensemble de plusieurs fichiers informatiques ayant des relations entre eux. Soit,
par exemple, les fichiers d'une application de gestion commerciale : le fichier des
clients, le fichiers des commandes et le fichier des livraisons. La gestion des
relations entre ces fichiers peut être réalisée classiquement par vos programmes,
c'est la méthode ancienne, sans SGBD.
Mais, de plus en plus fréquemment, le programmeur préfère utiliser un SGBD

(système de gestion de bases de données) qui lui évite de programmer ces liaisons
entre fichiers. Il faut donc acheter, en plus du système d'exploitation, ce logiciel
particulier qu'est le SGBD.
Quelques noms de SGBD pour micros : ORACLE, INFORMIX, dBASE,

PARADOX.
Et sur gros systèmes : encore ORACLE , DB2, DATACOM, POWERHOUSE.
Les plus évolués sont de type "relationnel", mais nous ne détaillerons pas ici les
fonctions particulières d'un SGBD relationnel. Dans le cas de l'OS/400, le SGBD
fait partie intégrante du système d'exploitation. Il a donc été conçu pour lui, et lui
est parfaitement adapté. Il n'a pas de nom particulier. Il s'agit d'un SGBD
relationnel, ou plutôt de type relationnel, car il ne correspond pas exactement aux
critères du relationnel. Peu importe, ses fonctions sont principalement les
suivantes :
- tout fichier peut être indexé, et avoir plusieurs index sur des champs simples ou
composés, contigus ou non contigus;
- la description des fichiers se fait à l'extérieur des programmes, donc une fois
pour toutes pour un fichier, et non pas une fois dans chaque programme qui utilise
le fichier;
- il est possible de prévoir des jointures entre deux fichiers, ce sont des liaisons
permanentes qui évitent des lectures;
- la protection de la base de données contre les indiscrétions est possible par le

système des mots de passe associés aux profils utilisateurs;

- la protection de la base de données contre les pannes est possible grâce, entre
autres, à un système d'enregistrement des mises à jour dans des "journaux".
2.5. Le moniteur de télétraitement est intégré
Le moniteur de télétraitement est un logiciel dont le seul rôle est de gérer la

simultanéité de fonctionnement de l'ensemble des terminaux. Tout comme le
SGBD, le moniteur de télétraitement est intégré à l'OS/400. Pas besoin de l'acheter
en plus. Ce n'est pas le cas chez BULL par exemple, avec le moniteur TDS, ou sur
les gros IBM avec CICS.
2.6. Les programmes utilitaires de l'OS/400
Il existe un certains nombre de programmes complémentaires de l'OS/400, on les

appelle les "utilitaires". Ce sont des sortes d'outils fournis par IBM et qui vont
servir au programmeur pour développer ses applications. Voici la liste des
principaux utilitaires IBM :
2.6.1. SEU = Source Entry Utility

En français, UCMS = Utilitaire de Création et de Maintenance de Sources.
C'est le programme qui vous permettra de saisir vos programmes GAP ou
COBOL dans l'ordinateur. C'est donc une sorte de programme de traitement de
textes, spécialement adapté toutefois à la saisie des programmes sources.
2.6.2. PDM = Product Development Manager

En français : gestionnaire de développement de produit logiciel. C'est la boîte à
outils du programmeur. Il donne accès de façon conviviale à la gestion de l'espace
disque, et vous permet de programmer confortablement.
2.6.3. SDA = Screen Design Aid

En français : ACMI = Aide à la Création et à la Maintenance d'Images écran.
Cet utilitaire sert à créer simplement (enfin, relativement), le dessin c'est-à-dire la
structure des écrans que vous concevrez. Il dispose d'une fonction annexe qui
permet de générer automatiquement des programmes de menus.

2.6.4. RLU = Report Layout Utility
En français : utilitaire de maquettage d'état. Permet de dessiner directement à
l'écran des maquettes d'état, plutôt que de devoir rédiger les descriptions de lignes
à imprimer. Fini le temps où le programmeur passait son temps à compter un par
un les caractères de ses états !
2.6.5. DFU = Data File Utility

En français: UCMF = Utilitaire pour la Création et la Maintenance de Fichiers.
Il permet de saisir ou de modifier directement le contenu d'un fichier, sans avoir à
écrire un programme pour cela. Ce système de mise à jour de fichier reste
forcément rudimentaire, et ne peut guère être mis dans les mains des utilisateurs
non informaticiens.
2.6.6. IDDU = Interactive Data Definition Utility

Traduisons comme d'habitude les mots anglais en commençant par la fin, c'est
donc un Utilitaire de Définition de Données Interactif.
Traduction de la traduction : nous avons dit tout à l'heure qu'avec la base de
données de l'AS/400, les fichiers sont décrits à l'extérieur du programme. Donc,
lorsque nous devrons créer de nouveaux fichiers, il nous faudra décrire la liste des
différentes rubriques qui composent un enregistrement. On rédigera, en dehors du
langage source de nos programmes, ce que l'on appelle des SDD. SDD signifie en
français: "Spécifications de Descriptions de Données", et bien sûr : DDS en
anglais ! Les SDD utilisent un langage spécifique à l'AS/400. Nous l'étudierons
plus loin dans ce livre.
Revenons à l'utilitaire IDDU. Au lieu de rédiger les SDD sur papier, puis de les
saisir à l'aide de l'utilitaire SEU, on peut faire générer automatiquement ces SDD
par IDDU. Cet utilitaire entamera avec nous un dialogue sur écran pour connaître
la structure de notre fichier. D'où le terme "interactif" justifiant le I de IDDU.
En fait, cet utilitaire, qui se veut plus convivial que la rédaction des SDD, s'avère,
à mon sens, plus complexe d'utilisation. Mais vous ferez votre choix vous-même
entre les deux solutions.
2.6.7. QUERY
En français : interrogation ou requête. Cet utilitaire permet d'imprimer toutes
sortes de listes, même assez sophistiquées, sans programmation.
Là aussi, c'est interactif. QUERY vous demande quel(s) fichier(s) vous voulez
lister, quelles colonnes vous voulez dans votre état, si vous voulez des totaux, des
sous-totaux, des comptages, des moyennes..., bref beaucoup de choses que l'on

passerait un temps fou à programmer, et qui deviennent pratiquement accessibles
à un utilisateur non informaticien, averti tout de même.
C'est un outil à connaître, si vous ne voulez pas voir un non-informaticien faire, en
quelques minutes, un état pour lequel vous venez de demander 3 semaines de
délai. Ne riez pas, de nombreux informaticiens y ont déjà perdu leur prestige, et
dans des circonstances semblables !
2.6.8. PCS = Personnal Computer Support

C'est un logiciel extrêmement puissant et complet qui permet de mettre en relation
un PC et un AS/400. Il est composé de deux parties bien distinctes : la partie qui
"tourne" sur le PC, et la partie qui "tourne" sur l'AS/400. Avec le logiciel PCS et
un micro-ordinateur connecté à l'AS/400, vous pourrez :
- émuler un terminal passif de type "5250", comme expliqué ci-dessus;

- utiliser l'imprimante de votre PC pour imprimer des fichiers de l'AS/400, mais
aussi utiliser l'imprimante de l'AS/400 pour imprimer vos fichiers PC;
- transférer des fichiers du PC vers l'AS/400 et réciproquement;
- stocker des fichiers PC au format MSDOS sur l'AS/400, et utiliser l'AS/400
comme serveur de fichiers MSDOS pour tous les micro-ordinateurs du réseau;
- communiquer par une messagerie;
- créer et utiliser des applications de "traitement coopératif".
Le traitement coopératif, comme son nom l'indique, permet de faire coopérer deux
ordinateurs, chacun ayant son rôle propre. C'est la notion très en vogue
actuellement d'architecture "client-serveur". Je me permets de m'étendre quelques
instants sur la question, car il semble que ce soit la voie de l'informatique de
demain. Sur le micro-ordinateur tournera un programme qui s'occupera surtout de
la gestion de l'interface utilisateur, autrement dit la gestion de l'écran qui sera de
type graphique, du clavier et de la souris, et demain des systèmes d'imagerie et de
son que nous promettent les futurs ordinateurs multimédias. C'est le programme
"client". Il faudra localement (au niveau du poste de travail) beaucoup de
puissance informatique pour cela, et les nouveaux micro-processeurs du marché
n'en manquent pas. On sera alors loin des terminaux non graphiques et
inintelligents actuels de type "5250" qui ne disposent, eux, d'aucune puissance
informatique locale.
Côté AS/400, un autre programme sera en fonction. C'est le programme "serveur".
Son rôle sera simplement de "servir" comme sur un plateau les données qui lui
auront été demandées par le client.
Un exemple : l'utilisateur du PC veut visualiser sur son écran les 5 dernières
sorties de stock de l'article X. A l'aide de sa souris, de son clavier, demain peut-
être de sa voix, il formule sa demande. Le PC interprète la demande, la
"décortique" et la transmet à l'AS/400 serveur, sous forme d'une requête générée
dans le langage SQL (voir explication ci-dessous). L'AS/400 fait la recherche dans
sa base de données, retourne au client la liste des 5 dernières sorties. Le PC reçoit
les données, et s'occupe de les afficher de façon conviviale, avec graphismes
agréables, icônes, couleurs...

Ainsi on utilise au mieux les possibilités d'ergonomie et de convivialié de la
micro-informatique, et on utilise aussi au mieux les possibilités de gestion de
grosses bases de données de l'AS/400 ou de tout autre gros système : gestion de
gros volumes, sécurité de la BD, partage des données entre les utilisateurs,
rapidité d'accès. On allie les points forts de la micro et les points forts des gros et
moyens systèmes. Ce sera le rêve !
2.6.9. EDU
IBM fournit avec l'AS/400, un logiciel d'auto-éducation. Il est en français ! Il
contient une trentaine de modules de vingt minutes chacun. Dans chaque module,
des questions sont posées à l'apprenant pour vérifier sa progression.
Très intéressant pour un débutant sur l'AS/400.
Voilà pour la liste des utilitaires. Profitons-en pour évoquer les progiciels (c'est-à-
dire PROduits loGICIELS) du marché.

2.7. Les logiciels AS/400 du marché
Pour ce qui est de la bureautique, on trouve essentiellement OFFICE 400, vendu

par IBM. C'est un logiciel de bureautique lourde.
D'excellents logiciels de gestion fleurissent chaque jour. Les classiques : paie,

comptabilité, gestion de stock, gestion du personnel. Mais aussi des logiciels dits
"verticaux", c'est-à-dire qui traitent tous les problèmes de gestion d'un secteur
professionnel. Par exemple : les logiciels pour garages automobiles, les logiciels
de cabinet d'analyse médicale, les logiciels pour avocats, etc.
Mentionnons aussi les "ateliers de génie logiciel". Rappelons ce que cache un

terme aussi provocateur que celui-là. Le génie logiciel n'est rien d'autre que la
programmation, le développement d'applications informatiques. Mais, pour épater
vos amis qui vous demandent à quoi vous occupez vos journées, préférez le terme
de "spécialiste en génie logiciel", ça fait tout de même plus chic que
"programmeur" ou pis "programmateur" qui peut faire penser aux dépanneurs de
machines à laver.
Un atelier de génie logiciel, donc, ou encore AGL en français et CASE en anglais

(Computer Aided Software Environment) retenez tout, c'est important pour briller
en société, est un ensemble d'outils qui permettent de développer plus vite. L'un
des principaux éléments d'un AGL est ce qu'on appelle un "L4G" ou Langage de
quatrième Génération. C'est un langage encore plus évolué que nos pauvres GAP,
COBOL, dBASE et autres langages de troisième génération seulement. La
quatrième génération tend à percer, mais peut-être pas aussi vite qu'on ne l'avait
prédit. Sur AS/400, les L4G s'appellent ADELIA, SYNON (préconisé par IBM),
AGLX.

2.8. L'organisation de l'espace disque
2.8.1. L'espace adressable unique
Tout d'abord, même si votre AS/400 possède plusieurs disques, le système

d'exploitation s'occupe de tout et répartit automatiquement, sans vous demander
votre avis, l'ensemble de vos fichiers et programmes sur l'ensemble des disques.
C'est ce qu'IBM appelle la notion d'"espace adressable unique". Vous avez à gérer
effectivement un espace disque unique. Qu'il soit constitué de 1, ou 2, ou 15
disques, peu importe, l'OS/400 vous décharge totalement de ce problème de
répartition sur les différents disques. Vous n'aurez donc jamais à dire à l'AS/400:
"Je veux mettre tel fichier sur tel disque", mais vous lui direz: "Je veux mettre tel
fichier sur disque", et c'est tout.
2.8.2. Les bibliothèques
L'espace disque est découpé logiquement (et non physiquement) en bibliothèques.

Dans une entreprise, on définira, par exemple, une bibliothèque pour contenir tout
ce qui concerne la comptabilité, une autre bibliothèque pour tout ce qui concerne
la gestion des stocks, une autre réservée aux programmeurs, etc.
Attention, ce n'est pas comme sous MSDOS ou UNIX où une bibliothèque (ou
répertoire) peut elle-même contenir une "sous-bibliothèque", et ainsi de suite. Sur
AS/400, la décomposition en bibliothèques n'a qu'un seul niveau, il ne peut donc
pas y avoir de sous-bibliothèque. Ce ne sera pas non plus comme sur IBM 36, où
une bibliothèque ne peut contenir que des programmes. Ici, programmes et
fichiers de données seront stockés dans des bibliothèques. La conséquence de tout
cela est donc : tout ce qui est stockable sur disque sera forcément stocké dans une
bibliothèque, et le corollaire : rien ne pourra être stocké en dehors des
bibliothèques.
2.8.3. Les objets

Nous venons de dire que l'espace disque se décompose au premier niveau en
bibliothèques. Pénétrons maintenant au sein d'une bibliothèque. Une bibliothèque
est exclusivement composée de ce qu'on appelle des objets. Je reprends et j'insiste
car l'expérience m'a prouvé maintes fois que cette notion était difficile à faire
passer ! L'espace disque est fait de bibliothèques et de rien d'autre. Chaque
bibliothèque est faite d'objets et de rien d'autre non plus. Ce terme d'objet est très
important. Car tout ce que vous aurez à stocker sur disque sera obligatoirement
stocké sous forme d'objets.

Mais, il existe de nombreuses catégories d'objets :
- les fichiers de données;

- les fichiers qui contiennent des programmes sources;
- les programmes compilés;
- les descriptions de profils utilisateurs;
- les files d'attente;
- etc.
L'objet est l'entité de base du disque. On dit que la gestion de l'espace disque par
le système d'exploitation est une gestion "orientée objet". Ça aussi, c'est un
concept à la mode qui prouve, à l'évidence, que vous avez évolué depuis les cartes
perforées !
Un objet sur AS/400 est composé de :
- un ensemble d'attributs qui décrivent cet objet;

- la "valeur" de l'objet.
Les attributs principaux d'un objet sont le nom de l'objet, le nom de son
propriétaire, le type d'objet, sa date de création, sa date de dernière sauvegarde, un
libellé en clair le décrivant sommairement, le nom de la bibliothèque auquel il
appartient.
La "valeur" de l'objet est en fait son contenu. Par exemple, la "valeur" de l'objet
fichier CLIENTS est l'ensemble des enregistrements de ce fichier. La "valeur" de
l'objet programme de paie est l'ensemble des instructions compilées de ce
programme.
Tout objet pourra être manipulé, on pourra par exemple :
- le copier d'une bibliothèque à l'autre;

- le déplacer dans une autre bibliothèque;
- le sauvegarder sur disquette;
- l'effacer;
- le rebaptiser;
- changer le nom de son propriétaire;
- réserver son accès à certaines personnes;
- etc.
Beaucoup de ces manipulations pourront être faites à l'aide de PDM, dont nous
avons parlé plus haut, et qui permet de gérer de façon conviviale les objets.

2.8.4. Les membres
Allons encore plus loin dans notre "décorticage" de l'espace disque. Nous avons
déjà décomposé l'espace disque en bibliothèques, puis les bibliothèques en objets.
Nous allons voir maintenant que certains objets se décomposent en "membres".
Ce sont les objets de type "fichiers", qu'ils soient des fichiers de données, ou des
fichiers contenant des sources de programmes.
Revenons... aux sources. Vous devez savoir qu'un programme doit d'abord être
écrit dans un langage tel que le GAP ou le COBOL. C'est ce qu'on appelle un
programme source. Puis, ce programme source est traduit, on dit compilé, en
langage machine, directement compréhensible par le processeur de l'ordinateur qui
pourra alors l'exécuter. Ce programme en langage machine est appelé le
"programme objet". Remarquez qu'ici le mot "objet" n'a rien à voir avec la notion
d'objet, sous-ensemble d'une bibliothèque, que nous venons d'étudier il y a
quelques instants ! N'hésitez pas à relire si ce n'est pas tout à fait clair dans votre
esprit.
Vous vous doutez que les programmes source que vous écrirez seront stockés sur
disque dans des fichiers, appelés fichiers source. Mais sur AS/400, dans chaque
fichier source, on peut stocker plusieurs programmes source. Chaque
programme constituera ce qu'on appelle un "membre" du fichier source.
Attention, le piège est qu'il n'en va pas de même des programmes objet. Chaque
programme objet (c.à.d. le résultat d'une compilation) sera stocké sur disque sous
forme d'un objet (c.à.d. le sous-ensemble d'une bibliothèque).
Par exemple, prenons un espace disque, qui ne contient que deux bibliothèques :
Bibliothèque COMPTA
- Objet fichier de données COMPTES
- Objet fichier de données FACTURE
- Objet fichier de programmes sources PROGCOMPT
* Membre programme source PG1
* Membre programme source PG2
- Objet programme compilé PG1
- Objet programme compilé PG2
Bibliothèque PERS
- Objet fichier de données PERSONNEL
- Objet fichier de programmes sources PGPER
* Membre programme source PAIE1
- Objet programme compilé PAIE1

Remarque : Beaucoup de bibliothèques et d'objets ont un nom qui commence par
la lettre "Q". Ils appartiennent en principe au système d'exploitation OS/400. Ils ne
doivent en aucun cas être modifiés, et encore moins supprimés. La plupart sont
protégés contre les maladresses...
2.9. Travaux batch et interactifs
En ce qui concerne le déroulement d'un programme sur l'AS/400, deux cas

peuvent se présenter.
2.9.1. Cas d'un travail interactif

Si le programme est lancé en interactif, il monopolise le terminal d'où on l'a lancé.
Le clavier reste verrouillé pendant tout le déroulement du travail. Et on ne peut
rien faire d'autre que d'attendre la fin du travail interactif en cours.
2.9.2. Cas d'un travail batch

Si le programme est lancé en batch, il se déroule tout seul dans l'unité centrale, il
n'a pas besoin de dialoguer avec le terminal. Le terminal est alors libéré et il
redevient disponible pour tout autre travail.
Prenons deux exemples de programmes.
Calcul de la paie
Le premier sera celui du calcul mensuel de la paie, supposons qu'il faille une
heure à l'ordinateur pour traiter tous les salariés de l'entreprise. Pendant ce
traitement d'une heure, le programme ne va que lire ou écrire des fichiers disque,
imprimer les bulletins de paie. Ce programme ne contiendra pas de dialogue avec
le terminal. C'est ce qu'on appelle un programme batch. Eh bien, ce programme
batch peut être lancé de deux façons.
La première : on peut lancer ce programme batch en interactif. Ce qui donnera

lieu à un travail interactif. On lance le programme à partir d'un terminal. Le

terminal sera bloqué, pendant tout le temps du calcul de la paie, c'est-à-dire peut-
être une heure pendant laquelle on ne pourra pas taper le moindre caractère au
clavier.
Deuxième méthode de lancement de ce programme batch : c'est le lancement

sous forme d'un travail batch. On lance le programme à partir d'un terminal. Une
ou deux secondes après, le terminal est libéré, c'est-à-dire qu'on peut à nouveau
faire autre chose. Mais, pendant ce temps, le calcul de la paie va s'exécuter dans
l'unité centrale, une heure durant.
Il vaut mieux lancer un programme de type batch sous forme d'un travail batch,
car:
- cela libère le terminal aussitôt;

- cela consomme moins de ressources système.
Notez en passant que le compilateur de programmes source est un programme de

type batch. Donc, lorsque vous compilerez vos programmes, lancez vos
compilations en batch, et non pas en interactif, pour éviter les inconvénients
évoqués ci-dessus.
Saisie des commandes client
Maintenant, nous avons affaire à un programme interactif, car c'est un programme

de saisie de données sur le terminal. Un dialogue s'établit entre le terminal et
l'unité centrale. Ici, il n'y a pas de dilemme, puisque le terminal est forcément
réquisitionné pendant toute la durée de la saisie. Ce sont donc forcément sous
forme de travail interactif que l'on pourra exécuter un programme interactif.

2.10. JOBQ et OUTQ
Prononcer "djobkiou" et "aoutkiou", ça fait plus distingué.
D'abord la JOBQ.
Nous venons de voir que certains travaux pouvaient se lancer en batch. Or
l'AS/400, bien que multitâche, est généralement configuré pour ne pouvoir
exécuter que 1 ou 2 programmes batch simultanément. Ce nombre de tâches
simultanées maximum est "réglable".
Supposez que 5 utilisateurs lancent à peu près en même temps leur travail batch,
et que "le goulot d'étranglement" qu'est le processeur ne peut en traiter que deux à
la fois :
- les deux premiers programmes vont pouvoir s'exécuter en même temps;

- les trois derniers vont être placés en attente dans une file d'attente appelée la
JOBQ, et s'exécuteront ensuite, dès que le processeur sera disponible.
La lettre finale Q de JOBQ, comme d'ailleurs d'OUTQ, signifie ici "queue", c'est-
à-dire file d'attente en anglais.
Parlons maintenant de l'OUTQ.

Vous aurez à l'utiliser très souvent. Imaginons que l'on lance deux travaux batch
en même temps, et que chacun de ces deux travaux imprime un état, l'un imprime
des bulletins de paie, et l'autre des factures. Qu'arrive-t-il ? A priori, un joyeux
mélange.
Je n'ose pas penser à l'employé recevant son bulletin de paie sur lequel on lui
ajoute la TVA, et le client recevant sa facture, avec des déductions pour la
Sécurité sociale !
Sur toute machine multitâche, ce problème doit être résolu. C'est ce qu'a fait IBM
en prévoyant dans l'OS/400 un système dit de "spool".
Le principe en est simple. Lorsqu'un programme d'impression se déroule, l'état

imprimé, au lieu d'être dirigé vers l'imprimante, est momentanément copié sur
disque, dans un fichier spécial, appelé fichier SPOOL. Avec ce système, vous
voyez que l'on peut exécuter plusieurs programmes d'impression simultanément,
puisque chaque programme d'impression va écrire son propre fichier SPOOL sur
disque.
Mais le système que je viens de décrire ne suffit pas, puisque, sous prétexte
d'éviter que les états ne se mélangent sur l'imprimante, on n'imprime plus rien du
tout !

Non, vous avez certainement deviné, qu'en plus du programme de paie et du
programme de facturation, on va lancer un troisième programme, dit programme
de SPOOL, ou encore WRITER sur l'AS/400.
C'est le programme de SPOOL, qui va relire le premier fichier SPOOL du disque

pour l'imprimer. Puis quand il sera imprimé, il passera au deuxième fichier
SPOOL, et le tour est joué, plus de mélange ! Génial, n'est-ce pas ?
Les fichiers SPOOL en attente d'impression sont placés dans une file d'attente
qu'on appelle OUTQ. On trouve souvent plusieurs OUTQ sur un AS/400. En effet,
si l'on dispose de plusieurs imprimantes, on créera en général une OUTQ par
imprimante.
Et pour chaque imprimante de l'ordinateur, il faudra lancer un (et un seul)
programme WRITER. Il peut donc y avoir plusieurs WRITER en cours s'il y a
plusieurs imprimantes sur l'ordinateur.
Comprenez bien et retenez bien le principe du SPOOL, car vous allez forcément le
manipuler : mettre un fichier impression dans une OUTQ, démarrer un WRITER,
bloquer et débloquer un fichier dans une file d'attente, l'effacer de la file d'attente,
etc. est le lot quotidien de tout analyste-programmeur sur AS/400.
Vous verrez que les commandes à passer pour ces manipulations sont simples, si
toutefois vous avez bien compris le principe.
Sinon, relisez ce chapitre tant qu'il n'est pas compris...

3. Débuter sur l'AS/400
3.1. Ouvrir une session
Vous pouvez maintenant vous mettre devant un terminal, car vous allez avoir des
manipulations à effectuer. Votre terminal est actuellement hors tension. Mettez-le
sous tension.
Après quinze secondes environ apparaît ce qu'on appelle l'écran d'ouverture, sur
lequel vous sont principalement demandés :
- votre nom d'utilisateur;

- le mot de passe associé à ce nom;
- la bibliothèque dans laquelle vous voulez vous placer dès le début.
Si cet écran n'apparaît pas, vérifiez les points suivants :
- n'y a-t-il pas une panne générale de courant ?

- le réglage de luminosité de votre terminal n'est-il pas à zéro ?
- l'unité centrale de l'AS/400 est-elle sous tension ?
- votre terminal est-il correctement relié à l'AS/400 ?
- votre terminal a-t-il la bonne adresse (de 0 à 6, voir plus haut) ?
- le terminator est-il bien positionné (1 ou 2) ?
Mais comme tout est OK, nous avons devant nous l'écran d'ouverture qui nous
tend les bras.
Nous supposerons qu'un nom d'utilisateur, ce que l'on appelle un "profil

utilisateur", vous a déjà été affecté par le responsable de la sécurité de l'AS/400,
qu'IBM appelle l'"officier de sécurité".
Vous tapez donc votre nom de profil, puis votre mot de passe.
Lorsque l'officier de sécurité déclare à l'AS/400 un nouveau profil, le mot de passe
est généralement égal au nom de profil. Mais vous pourrez et devrez même le
changer.
Laissez pour l'instant vides les autres rubriques de l'écran d'ouverture et appuyez
sur la touche ENTREE. Alors apparaît le "menu principal".

3.2. Les menus et les commandes
Nous vous avons parlé au début des 900 commandes disponibles dans le langage
de l'OS/400. Une grande partie de ces 900 commandes sont directement
accessibles par un système de menus.
Il est donc possible de lancer des commandes du langage CL sans s'en rendre
compte, simplement en choisissant des options et des sous-options dans
l'importante arborescence des menus et des sous-menus.
Une autre possibilité consiste à taper la commande en toutes lettres suivie de ces
paramètres. Voici au hasard quelques exemples de commandes :
CRTPRTF FILE(ETAT5) SRCFILE(QDDSSRC) PAGESIZE(55)
SAVLIB LIB(AP16XY) DEV(DKT01) EXPDATE(*PERM)
DSPSYSVAL SYSVAL(QAUTOCFG) OUTPUT(*PRINT)
CALL PGM(PAIE) PARM('Janvier')
CALL PAIE 'Janvier'
WRKSPLF
C'est un peu moins convivial que le système des menus, mais c'est souvent plus
rapide. Un analyste-programmeur doit utiliser plutôt les commandes que les
menus, au moins pour les commandes courantes.
En plus, cela lui permettra d'apprendre quelques-unes des 900 commandes, ce qui
lui rendra service quand il devra réaliser de petits programmes en langage CL,
dans lesquels il sera impossible d'utiliser le système des menus.
Mais revenons aux exemples ci-dessus de commandes du langage CL pour en

étudier leur structure. Chaque ordre commence par le nom de la commande. Nous
avons ici les noms de commandes CRTPRTF, SAVLIB, DSPSYSVAL, CALL,
WRKSPLF.
Viennent ensuite les paramètres de la commande. Une commande peut nécessiter

zéro, un ou plusieurs paramètres.
Chaque paramètre porte un nom, par exemple FILE, SRCFILE, PAGESIZE,

LIB,...
Certains paramètres sont obligatoires, d'autres facultatifs.

La valeur du paramètre doit être placée entre parenthèses, juste après le nom du
paramètre.

Toutefois, on peut éviter de taper le nom des paramètres, et placer les paramètres
proprement dits directement après le nom de la commande. Ce ne sera possible
que si le ou les N paramètres spécifiés correspondent exactement aux N premiers
paramètres définis par IBM dans la commande.
Ce système de paramétrage est appelé "paramétrage positionnel", par opposition à
celui vu précédemment qui est le "paramétrage à l'aide de mots clés".
Relisez attentivement les deux commandes CALL présentées ci dessus, elles sont
parfaitement équivalentes. Elles illustrent les deux modes de paramétrage.
Certaines valeurs de paramètres sont précédées d'un astérisque. Ce sont des

valeurs standard.
Mais vous devez être effrayés par le nombre de commandes à connaître d'une part,
et ensuite par la liste des paramètres à connaître pour chacune de ces commandes.
Et vous avez bien raison, car IBM explique tout cela dans 5 gros manuels de
référence, ayant chacun quelques centimètres d'épaisseur.
Heureusement, un petit résumé de ces 5 tomes existe, c'est un manuel de....
696 pages, toujours en anglais !
Allez, j'arrête de jouer avec vos nerfs.
Ce n'est pas si désespérant, car IBM a prévu un système extrêmement complet

d'"aide en ligne", et en français.
Comment l'utiliser ?
3.2.1. Trouver la bonne commande

D'abord, pour retrouver la bonne commande, mettez votre curseur sur une ligne
blanche soulignée en bas de l'écran, appelée la ligne de commande. Ne saisissez
rien sur cette ligne, mais appuyez sur la touche guide F4 (ou tapez sur la touche
SEL CDE puis sur la touche 4 si vous disposez d'un modèle ancien de terminal).
Vous voyez apparaître une liste des thèmes des commandes CL. Choisissez le bon
thème, et vous arrivez ainsi à trouver le nom de la commande désirée et tous ses
paramètres.
Essayez de retrouver ainsi la commande qui vous permet de modifier votre profil
utilisateur. Et changez effectivement le texte de description de votre profil, et rien
d'autre ! car vous risqueriez des ennuis par la suite. Tapez vos nom et prénom dans
cette zone de description.
Vous avez trouvé, je suppose, qu'il s'agit de la commande :
CHGPRF

3.2.2. Trouver les paramètres
Maintenant, autre scénario.
Supposons que vous vous souveniez que la commande s'appelle CHGPRF, mais
vous n'en connaissez pas les paramètres.
Tapez alors dans la ligne de commande, en bas de l'écran, le nom de la
commande, c'est-à-dire CHGPRF.
Puis appuyez sur la touche guide F4. Vous voyez alors apparaître la liste des
paramètres disponibles. Dans beaucoup de commandes, seuls les paramètres les
plus courants apparaissent, vous appuierez alors sur la touche F10 pour avoir la
liste exhaustive de tous les paramètres de la commande.
Faites l'essai.
3.2.3. Trouver la valeur d'un paramètre

Encore plus fort : si vous ne savez pas comment remplir un paramètre, placez
votre curseur sur ce paramètre, appuyez sur F1 (la touche magique d'aide qui est
pratiquement disponible partout sur l'AS/400), un écran vous affiche le rôle du
paramètre. Après avoir lu, revenez à l'écran précédent par la touche F3.
Avec votre curseur toujours positionné sur un paramètre, appuyez sur F4 et vous
aurez la liste des valeurs possibles à saisir.
3.2.4. Taper directement la commande

Dernier scénario enfin. Vous connaissez la commande sur le bout des doigts, vous
tapez directement :
CHGPRF TEXT('Euphrasie LAROUSSE')
Refaites maintenant des essais similaires pour changer et personnaliser votre mot
de passe.
Vous voyez qu'il ne sera pas indispensable d'apprendre tout par coeur, mais la
touche guide F4 et la touche d'aide F1 ne doivent surtout pas vous dispenser de
rechercher par vous-même dans la documentation IBM.
Car c'est toujours là que l'on retrouve l'information la plus exacte, la plus précise,
la mieux expliquée, même si c'est en anglais.
Et même si vous croyez perdre du temps, vous vous apercevrez vite de

l'investissement en connaissances que vous apporte ce "temps perdu".

3.2.5. Les touches standardisées de l'AS/400
Un certain nombre de touches fonctions ont été standardisées par IBM. Cette
standardisation fait partie de la norme appelée SAA : Systems Applications
Architecture, en français : AUA = Architecture Unifiée d'Applications.
Vous risquez de rencontrer de plus en plus cette norme, puisque IBM l'applique
progressivement à toute sa gamme de machines et de logiciels, et comme IBM
n'est pas le plus petit des constructeurs informatiques... On retrouve cette norme
SAA :
- sur micro, dans l'interface graphique Windows;

- dans le système d'exploitation micro OS/2;
- dans le système d'exploitation OS/400 bien sûr;
- dans les deux systèmes d'exploitation des "main frames" IBM : VM et MVS.
Récapitulons les touches magiques SAA que nous avons déjà rencontrées :
- la touche F1 = touche d'aide

- la touche F4 = touche guide
- la touche F10 = liste complète des paramètres
Encore une petite information sur la touche F1.

Lorsque vous recevez un message, souvent hélas un message d'erreur, celui-ci
apparaît sur la dernière ligne en bas de l'écran. Si vous descendez votre curseur
dans ce message, et que vous appuyez sur F1 ou sur AIDE, vous aurez des
explications plus détaillées sur ce message.
D'autres touches SAA, maintenant.

La touche F9 permet de retrouver les dernières commandes que vous venez de
taper. Malheureusement, la touche F9 ne permet que de remonter en arrière, mais
pas de revenir en avant.
La touche F3 vous permet de quitter l'option en cours.
La touche F12 vous permet de revenir à l'écran précédent, ce n'est pas exactement
la même chose que la touche F3, contrairement aux apparences.
La touche F5 permet de réactualiser les données affichées sur un écran.

3.2.6. La structure des noms de commande CL
La plupart des noms de commandes CL peuvent se retrouver intuitivement. Il
suffit de savoir comment elles sont construites. Les 3 premiers caractères
correspondent au verbe de la commande, et les suivants à l'entité traitée par la
commande.
Par exemple :
CHGPRF
verbe: CHG c'est-à-dire CHanGe
entité: PRF c'est-à-dire PRoFile = profil en français
DSPSYSVAL
verbe: DSP c'est-à-dire DiSPlay = afficher en français
entité: SYSVAL c'est-à-dire SYStem VALue = valeur
système en français
A l'aide de ces verbes, vous pourrez composer 95% des commandes CL :
ADD = ADD = ajouter à une liste

CHG = CHANGE = changer
CLR = CLEAR = efface
CPY = COPY = copier
CRT = CREATE = créer
DLT = DELETE = efface
DSP = DISPLAY = afficher
EDT = EDIT = modifier
END = END = terminer
GRT = GRANT = accorder
INZ = INITIALIZE = initialiser, formatter
MOV = MOVE = déplacer
OVR = OVERRIDE = changer de
PRT = PRINT = imprimer
RMV = REMOVE = supprimer
RST = RESTORE = restaurer
RTV = RETRIEVE = retrouver
SAV = SAVE = sauvegarder
SND = SEND = envoyer
STR = START = démarrer
WRK = WORK = gérer, travailler avec

Voyons maintenant quelques noms habituels d'entités que l'on peut associer aux
verbes ci-dessus pour composer une commande :
LIB = LIBRARY = bibliothèque

F = FILE = fichier
SPLF = SPOOL FILE = fichier SPOOL
SRCF = SOURCE FILE = fichier source
MBR = MEMBER = membre
OBJ = OBJECT = objet
PRF = PROFILE = profil utilisateur
PGM = PROGRAM = programme
DEV = DEVICE = appareil
LIBL = LIBRARY LIST = liste de
bibliothèques
DKT = DISKETTE = disquette
JOB = JOB = travail
JOBQ = JOB QUEUE = file d'attente de travail
OUTQ= OUT QUEUE = file d'attente de
sortie
PRTF = PRINTER FILE = fichier impression
etc. et la liste est longue !
Evidement, toutes les combinaisons de verbes et d'entités ne sont pas possibles.

Mais avec un peu d'intuition et d'habitude, on retrouve vite les noms des
commandes, même si parfois on en invente qu'IBM n'a malheureusement pas
prévues.
3.3. Fermer une session
Ce qu'il ne faut jamais faire : couper le courant du terminal n'importe quand. Vous
devez impérativement revenir à l'écran d'ouverture, souvenez-vous, celui où l'on
tape le nom de profil et le mot de passe. Seulement à ce moment, vous pouvez
couper le courant du terminal.
Si par mégarde, vous coupiez le courant sans revenir sur l'écran d'ouverture, ce ne
serait pas une catastrophe pour autant. Votre terminal serait désactivé, et il
faudrait une manipulation de l'opérateur système pour le réactiver. De plus vous
risqueriez de perdre totalement les données en cours ou le programme en cours de
réalisation, ce qui peut être tout de même gênant.
Donc, il faut revenir à l'écran d'ouverture. Cela se fait par la commande :

SIGNOFF
tapée telle quelle sans paramètre, dans la ligne de commande. Vous pouvez aussi,
comme pour la plupart des commandes CL, déclencher une commande SIGNOFF
par une option d'un menu. C'est donc l'option 90 du menu principal qu'il faut
choisir.
Faites maintenant l'essai : arrêtez votre terminal par la commande SIGNOFF puis,
rouvrez une session, et arrêtez-la à nouveau par la deuxième méthode, c'est-à-dire
l'option 90 du menu principal.
3.4. Créer une bibliothèque
Il va falloir vous faire une petite place dans l'espace disque de l'AS/400. Créez
donc vous-même votre propre bibliothèque. Ne lui choisissez pas n'importe quel
nom, mais renseignez-vous sur les normes en vigueur sur votre machine.
Supposons que votre profil utilisateur s'appelle XY et que vous désiriez appeler
votre bibliothèque ESSAIXY, vous taperez :
CRTLIB LIB(ESSAIXY)
Vous allez devoir maintenant indiquer à l'OS/400 que c'est cette bibliothèque
ESSAIXY que l'utilisateur XY utilisera prioritairement.
Prioritairement, cela signifie que dans la suite de votre travail sur le terminal, si
vous ne spécifiez pas de nom de bibliothèque particulier, vos programmes et vos
données iront automatiquement se placer dans la bibliothèque ESSAIXY. Pour
faire cette liaison entre le nom de profil et le nom de bibliothèque, tapez une fois
pour toutes la commande suivante :
CHGPRF CURLIB(ESSAIXY)
Ce qui signifie en clair et en français : "changer mon profil utilisateur pour que ma
bibliothèque courante (CURLIB = current library) devienne ESSAIXY".
Pour que cette commande soit réellement prise en compte, il vous faut encore
quitter la session (SIGNOFF), et la rouvrir.
Pour vérifier que la CURLIB est bien maintenant ESSAIXY, tapez la commande:
DSPLIBL
Vous verrez s'afficher une liste de bibliothèques, au sein de laquelle votre

bibliothèque ESSAIXY doit figurer avec la mention CURLIB. Pour les habitués
du MSDOS, la CURLIB correspond au répertoire courant que l'on peut changer
avec l'ordre CD, et la liste LIBL correspond au PATH.

3.5. Créer un fichier source
Vous souvenez-vous de l'explication sur les fichiers sources, qui se décomposent

en membres ?
Si ce n'est plus très clair, revenez à cette explication.
Vous allez devoir créer dans votre bibliothèque, qui est encore vide, un fichier
source. C'est dans ce fichier source que vous saisirez vos programmes GAP
(=RPG), ou COBOL à raison d'un programme par membre de fichier source.
Pour créer votre fichier source, tapez la commande CL suivante :
CRTSRCPF FILE(QRPGSRC)
pour du source GAP, ou :
CRTSRCPF FILE(QCBLSRC)
pour du source COBOL.
Ce qui signifie : "créer un fichier source physique dont le nom sera QRPGSRC".
Vous pouvez en plus vérifier que le fichier source QRPGSRC ou QCBLSRC a
bien été créé en tapant la commande :
DSPLIB LIB(ESSAIXY)
Je suppose que vous avez compris le but de la commande DSPLIB, rien qu'en
regardant son nom. Elle signifie bien sûr : "DISPLAY LIBRARY", c'est-à-dire
"afficher le contenu de la bibliothèque ESSAIXY".
3.6. Saisir un membre source

Si vous avez un programme prêt à saisir, vous allez pouvoir le faire maintenant.
Supposons qu'il s'agisse d'un programme GAP nommé PROG1.
Vous allez utiliser le programme utilitaire de saisie de programmes source, nous

en avons déjà parlé, il se nomme SEU. Cet utilitaire est assez convivial, et ce sera
à vous de découvrir son mode d'emploi, en vous servant intensivement de la
touche d'aide F1.

Voyons tout de même comment démarrer SEU. Vous pouvez le lancer de deux
manières.
La première. Tapez la commande CL :
STRSEU SRCFILE(QRPGSRC) SRCMBR(PROG1) TYPE(RPG)
La seconde manière maintenant. Vous allez utiliser l'utilitaire gestionnaire de

développement PDM. Tapez la commande CL :
STRPDM
Trois options apparaissent : la première permet de gérer des bibliothèques, la

deuxième accède au niveau inférieur : celui des objets, et la troisième accède au
dernier niveau : celui des membres.
Choisissez l'option 3 pour travailler sur un membre source. Tapez le nom du
membre.
Essayez les 2 méthodes, et choisissez celle qui vous paraît la plus commode. Vous
pouvez saisir le source de votre programme PROG1.
Pour quitter la saisie, utilisez comme d'habitude la touche d'abandon F3.
3.7. Compiler un programme
Maintenant que votre programme est saisi, vous savez certainement qu'on ne peut
pas l'exécuter tel quel. Il faut d'abord le traduire dans le langage de base du
processeur : le langage machine. C'est la phase de compilation, qui a pour résultat
un programme dit "programme objet". Nous allons voir comment faire faire une
compilation.
Puis nous étudierons comment voir si la compilation s'est bien passée, et comment
voir les erreurs de compilation. Il y a erreur de compilation lorsque le compilateur
trouve un ordre mal rédigé, qu'il ne peut pas comprendre.
Pour compiler, on peut utiliser la commande CL directe, qui est :
CRTRPGPGM
c'est-à-dire : "create RPG program". Mais dans votre cas, il est beaucoup plus
simple d'utiliser le système de menus, car les paramètres de l'ordre CRTRPGPGM
sont assez complexes et nombreux.
De plus l'utilitaire PDM nous offre une possibilité très simple de compiler. Il suffit
de taper l'option 14 en face du nom du programme à compiler. La compilation se
lancera en batch. Votre terminal va donc être libéré de suite.

Vous pouvez visualiser, et même gérer l'état des travaux batch que vous avez
soumis. Utilisez pour cela la commande :
WRKSBMJOB
qui signifie "WORK WITH SUBMITTED JOBS", c'est-à-dire "gérer les travaux
batch soumis".
Ou encore, pour visualiser l'historique de votre session, c'est-à-dire du travail

interactif en cours sur votre terminal, tapez la très intéressante commande :
DSPJOBLOG
qui signifie : "DISPLAY JOB LOG", c'est-à-dire "afficher l'historique du travail".
3.8. Gérer les fichiers d'impression
Votre compilation est maintenant terminée.
Vous pouvez visualiser le résultat de la compilation, car c'est un état qui est stocké
pour l'instant sous forme d'un fichier d'impression dans une OUTQ. Revoir plus
haut ces notions si ce n'est pas tout à fait limpide. Pour visualiser la liste de vos
états en attente d'impression, tapez la commande CL:
WRKSPLF
qui signifie "WORK WITH SPOOLED FILES", c'est-à-dire "gérer les fichiers
spool". Si vous avez des erreurs de compilation, vous aurez non pas un mais deux
fichiers SPOOL, le deuxième s'appelant QPJOBLOG, et n'ayant en fait guère
d'intérêt.
Visualisez votre fichier d'impression à l'écran, utilisez la touche F1 ou AIDE pour

apprendre à manoeuvrer les possibilités de la commande CL : WRKSPLF. Et si
vraiment vous n'y voyez pas suffisamment clair en visualisant votre résultat de
compilation sur votre écran, imprimez-le sur papier, et tant pis pour les arbres de
nos belles forêts !
Faites régulièrement le ménage dans vos fichiers d'impression en attente en

utilisant l'option 4 de suppression. Inutile d'encombrer le disque avec de vieilles
impressions. Une fois les erreurs de compilation identifiées, revenez à votre
programme source, et corrigez-le. Sachez que vous pouvez, si vous le souhaitez,
visualiser simultanément, sur le même écran :
- votre programme source;

- votre liste d'erreurs de compilation.
Votre écran sera découpé en deux fenêtres superposées verticalement. C'est dans
SEU que cette possibilité est offerte, vous trouverez les explications dans l'aide de
SEU en pressant sur la touche F1. Essayez, cela vaut le détour.
3.9. Exécuter un programme
Après correction de vos erreurs de compilation, vous voudrez certainement

essayer votre programme.
Si votre programme, qui dans notre exemple s'appelle PROG1, est un programme
de type batch, exécutez-le sous forme d'un travail batch par l'ordre suivant :
SBMJOB CMD(CALL PROG1)
S'il s'agit d'un programme interactif, vous ne pouvez le lancer qu'en interactif par
l'ordre :
CALL PROG1

4. Le langage GAP
4.1. Généralités sur le GAP
IBM propose sur son AS/400 les langages de programmation suivants :
- BASIC
- Langage C
- COBOL 85
- FORTRAN
- PASCAL
- PL/I
- RM/COBOL
et bien sûr :
- GAP
Le langage GAP est un langage créé par IBM il y a vingt ans environ. GAP
signifie Générateur Automatique de Programme, le nom anglais étant RPG, c'est-
à-dire "Report Program Generator", qui a une signification sensiblement différente
: Générateur de Programme d'Impression.
C'est un langage de troisième génération, comme la plupart des langages actuels.

Il est livré par IBM à ses clients sous forme d'un compilateur stocké sur support
magnétique (cassette ou disquette). Il est accompagné de deux brochures en
anglais.
Rappelons qu'un compilateur n'est rien d'autre qu'un programme qui sert à
traduire des programmes écrits en langage évolué (de troisième génération) vers le
langage machine, qui est le seul langage que le processeur soit capable de
comprendre.
Revenons sur le terme de "générateur automatique de programme". Si cette notion

correspondait effectivement à l'esprit du GAP il y a vingt ans, ce n'est pas à
proprement parler un "générateur de programmes" comme peut l'être un L4G
(langage de quatrième génération) d'aujourd'hui.
Le GAP fonctionne essentiellement sur la gamme des "moyens systèmes" d'IBM,

c'est-à-dire les anciens IBM32, IBM34, IBM36, IBM38 et les actuels IBM
AS/400.

On trouve cependant des compilateurs GAP sur "gros systèmes" IBM : les IBM
43xx et les IBM 309x. Mais le GAP reste très peu utilisé sur ces "main-frames".
Après le GAP 1 est né le GAP 2 sur IBM34, puis le GAP 3 sur IBM 38, et enfin le
GAP 400 sur AS/400. C'est évidemment ce dernier que nous allons étudier.
Quelques autres constructeurs tels qu'UNISYS et BULL ont créé leur compilateur
GAP, mais sans grande diffusion.
Finalement qui dit GAP, dit presque toujours mini-ordinateur IBM.
Notez que 90 pour 100 des AS/400 sont programmés en GAP, et 10 pour 100
seulement en COBOL.
Quand on sait, de plus, que sur les 22 000 sites mini d'IBM installés en France
(36, 38, AS/400), 5 000 se sont déjà convertis à l'AS/400 (chiffres d'avril 1991), et
que les 17 000 autres vont vraisemblablement y passer bientôt, on voit que la
connaissance de l'AS/400 et du GAP sont des cordes indispensables à l'arc de tout
analyste-programmeur !
La phase de motivation du lecteur étant maintenant terminée, et espérons-le

réussie, entrons dans le vif du sujet.
4.2. La structure du langage
Le langage GAP a l'avantage d'être un langage compact tout en restant lisible. Il

est moins "verbeux" que le COBOL.
Il dispose d'un outil assez séduisant, qu'on ne retrouve pas dans les autres langages
: ce sont les indicateurs. Les indicateurs sont des variables binaires (zéro ou un)
que nous étudierons plus loin.
Le GAP peut être programmé de deux façons radicalement différentes, tellement

différentes que cela revient presque à deux langages différents.
4.2.1. La programmation en cycle

La structure du programme à écrire est prédéterminée par un cycle immuable. En
clair, l'arbre programmatique ou encore l'organigramme de votre programme est
déjà établi par le GAP avant même l'écriture du programme. C'est une structure
très générale qui permet tous les cas, et dans lequel le programmeur n'a qu'à
remplir les pavés et à préciser les conditions des alternatives et des répétitives.

Cela convient particulièrement bien aux programmes d'édition en batch avec des
ruptures et des sous-totaux.
4.2.2. La programmation hors cycle
Ce mode de programmation correspond à la façon classique de programmer, celle

que l'on retrouve dans tous les autres langages. La programmation hors cycle est
aujourd'hui beaucoup plus répandue que la programmation en cycle. Elle convient
d'ailleurs beaucoup mieux aux programmes interactifs, qui représentent 80 pour
100 des programmes actuels.
C'est donc la programmation hors cycle que nous étudierons ici.
4.2.3. Les spécifications

Dans le vocabulaire du langage GAP, tout ordre s'appelle une "spécification". Une
spécification est généralement l'équivalent d'une ligne de programme. Il existe
plusieurs catégories de spécifications :
- les spécifications H;
- les spécifications F;
- les spécifications E;
- les spécifications L;
- les spécifications I;
- les spécifications C;
- les spécifications O.
Retenez le mot magique "HFELICO", il vous aidera à retrouver la séquence

obligatoire des ordres GAP.
Regardez en annexe 1 un exemple de programme GAP, juste pour vous donner

une idée de ce à quoi cela peut ressembler.
Passons très rapidement en revue les différentes catégories de spécifications :
La spécification H comme Header = en-tête
Une spécification H maximum par programme.

Elle contient des mentions relatives à l'ensemble du programme. Elle n'est
nécessaire que dans certains cas particuliers.

Les spécifications F comme File = fichier
Une spécification F pour décrire chaque fichier utilisé.
Attention, sur l'AS/400, on entend par fichier aussi bien un fichier disque normal
qu'un fichier imprimante, ou un fichier écran.
En effet, lorsque l'on veut envoyer des données sur l'imprimante, ou à l'écran, on
écrit ces données dans ce qu'IBM appelle un "fichier imprimante" ou un "fichier
écran" .
Donc, si votre programme lit deux fichiers, et imprime un état, vous aurez
3 spécifications F à rédiger.
Nous reviendrons plus loin sur ce que vous devrez écrire dans ces spécifications
F.
Les spécification E (comme Extension)
Elles servent à définir des tableaux en mémoire, ce que nous verrons plus loin
dans un chapitre spécifique.
Les spécifications L (comme Line = ligne)
Elles servent à définir des sauts de page particuliers sur imprimante, que nous
n'utiliserons pas.
Les spécifications I (comme Input = entrée)
Elles servent à décrire les enregistrements en entrée du programme. Dans la

plupart des cas, sur l'AS/400, cela est fait automatiquement, vous n'aurez donc pas
de spécifications I à écrire.
Les spécifications C (comme Compute = calcul ou traitement)
Là, vous allez malheureusement devoir "gratter" !

C'est en effet dans les spécifications C que s'écrivent tous les ordres de traitement
de votre programme.
Les spécifications O (comme Ouput = sortie)

Elles servent à décrire les enregistrements en sortie du programme. Dans la
plupart des cas, sur l'AS/400, cela est fait automatiquement, vous n'aurez donc pas
de spécifications O à écrire non plus.
Résumons-nous : pour un programme simple d'édition qui lit un fichier et qui

l'imprime, vous aurez à écrire :
- une spécification F pour le fichier en entrée;

- une spécification F pour le "fichier" imprimante;
- des spécifications C pour le traitement.
Comme vous l'avez vu dans l'exemple de programme GAP en annexe, écrire une
spécification GAP, c'est remplir des cases en respectant scrupuleusement les
colonnes indiquées. Programmer en GAP ressemble finalement beaucoup à
remplir une feuille de Sécurité sociale!
4.2.4. Règles communes à toutes les spécifications

Voici des règles de remplissage communes aux 7 catégories de spécifications :
- les spécifications doivent toujours être écrites dans l'ordre HFELICO;
- le code de la spécification (H ou F ou E ....) doit être saisi en colonne 6;
- en plaçant un astérisque en colonne 7, on transforme un ordre en simple

commentaire que le compilateur ne cherchera même pas à traduire. Les
commentaires dans les programmes sont indispensables pour assurer la clarté et la
lisibilité ultérieure du programme.
Vous trouverez, en annexe 2, des grilles de saisie vierges de chacun de 7 types de

spécifications GAP.
4.2.5. Remarques sur la documentation IBM
Nous allons entrer maintenant dans le vif du sujet, c'est-à-dire dans le détail des
ordres GAP. Vous trouverez dans la suite de ce livre le minimum pour que vous
puissiez programmer, mais vous aurez vite besoin d'aller plus loin, par exemple
pour trouver le petit paramètre qui vous fait défaut.
IBM distribue avec son compilateur GAP une documentation extrêmement

complète, fiable, et facilement accessible avec de bons index qui permettent de
retrouver très rapidement l'information recherchée. C'est vraiment LA BIBLE.

La documentation se compose de deux livres : le livre de référence du GAP
nommé "RPG/400 REFERENCE" avec tous les ordres par ordre alphabétique,
et aussi un livre plus pédagogique organisé par thème, c'est le "RPG/400
PROGRAMMER'S GUIDE" le guide du programmeur.
Malheureusement, cette documentation est en anglais.
Nous ne saurions que trop conseiller aux futurs analystes-programmeurs sur

AS/400 de se forcer à "perdre du temps" à rechercher dans la documentation du
constructeur.
Si c'est effectivement une perte de temps au début, c'est surtout un prodigieux

investissement pour votre avenir.
L'informaticien est condamné à l'autoformation permanente s'il veut maintenir

à jour ses connaissances. Il doit en prendre l'habitude dès son...plus jeune âge.
Ne soyez pas rebuté par l'anglais, le vocabulaire informatique est très limité, les
structures grammaticales anglaises aussi. Prenez le temps d'ouvrir le dictionnaire
anglais, votre avenir en dépend.
Un ami qui vous veut du bien....

4.3. Les spécifications F
Voyons maintenant en détail comment remplir une spécification F.
colonnes 7 à 14 : nom du fichier sur le disque, ou du fichier imprimante, ou du

fichier écran. Un nom de fichier peut avoir jusqu'à 8 caractères.
colonne 15 : mode d'accès au fichier, choisir une des lettres suivantes :

I = Input pour un fichier en entrée,
c'est-à-dire en lecture seulement
O = Output pour un fichier en sortie,
c'est-à-dire en écriture seulement
U = Update pour un fichier en mise à jour,
c'est-à-dire en lecture et en écriture
C = Combined pour les fichiers écran seulement.
colonne 16 : mettre F pour "Full procedural", ce qui signifie que le fichier

n'est pas traité en cycle mais hors cycle.
colonne 19 : mettre E pour indiquer que la description de la structure de

l'enregistrement (c'est-à-dire de ses différentes rubriques) n'est
pas faite dans le programme par des spécifications I, mais
qu'elle a déjà été faite une fois pour toutes à l'extérieur du
programme par les SDD (nous reviendrons sur ce que sont
les SDD plus tard).
colonne 31 : mettre K (comme Key) si le fichier est indexé, il sera donc

accessible par une clé.
colonnes 40 à 46: indiquer le type de fichier, à savoir :

DISK, s'il s'agit d'un fichier disque normal
PRINTER, s'il s'agit d'un fichier imprimante
WORKSTN, s'il s'agit d'un fichier écran
colonne 66 : mettre un A (comme Add) dans le cas d'un fichier disque sur
lequel vous voulez pouvoir ajouter des enregistrements.
Attention : on oublie souvent de mettre ce A quand il est
nécessaire.
Retrouvez en annexes 1 et 2 les différentes colonnes des spécifications F.

4.4. Les spécifications C
C'est donc dans ces spécifications que nous écrirons l'algorithme de notre
programme. On y trouvera donc des ordres de calcul, des ordres de structures
alternatives et répétitives, des ordres d'écriture sur les fichiers, etc.
Ces différents ordres (que l'on appelle aussi codes opération) sont au nombre de
82. Nous n'en étudierons qu'une dizaine. Voyons d'abord l'ensemble des règles
communes à tous les codes opérations.
colonnes 7 à 17 : on y place de 0 jusqu'à 3 indicateurs de conditionnement. Les

indicateurs sont des variables en mémoire de type binaire. Elles
ne peuvent prendre que deux valeurs '0' ou '1'.
Ces variables sont identifiées par leurs numéros qui est compris
entre 01 et 99. Si l'indicateur ou les indicateurs d'une
spécification C sont à 1, alors l'ordre sera exécuté, sinon, l'ordre
ne sera pas exécuté et l'exécution passera directement à l'ordre
suivant en sautant cet ordre.
colonnes 18 à 27: facteur 1.

Certains codes opération nécessitent des paramètres, encore
appelés facteurs. Il peut y avoir deux facteurs, le premier doit se
placer en colonne 18 et le deuxième en colonne 33.
colonnes 28 à 32: code opération.

C'est ici que l'on écrira le nom de l'ordre que l'on veut exécuter.
colonnes 33 à 42: facteur 2.

Voir explication du facteur 1.
colonnes 43 à 53: zone résultat.

On y écrira généralement le nom de la zone contenant le résultat
de l'opération.
colonnes 54 à 59: indicateurs résultants.

Le résultat d'une opération peut être un ou des indicateurs. On
indiquera éventuellement leurs numéros ici.
colonnes 60 à 74: c'est une deuxième possibilité pour écrire des commentaires
libres qui clarifieront la relecture du programme en cas
(plus que probable) de maintenance ultérieure.
Mais tout cela est encore bien abstrait. Passons maintenant aux principaux ordres
que vous aurez à coder dans les spécifications C.

4.5. Les ordres de calcul et de transfert
4.5.1. Ordres ADD et Z-ADD
C'est l'ordre qui permet de faire une simple addition de deux nombres.
Prenons par exemple deux zones en mémoire appelées HT et TVA que l'on veut
additionner pour obtenir le total dans la zone appelée TTC.
HT sera écrit en zone facteur 1.

Le code opération ADD sera écrit en zone code opération.
TVA sera écrit en zone facteur 2.
TTC sera écrit en zone résultat.
Ce qui donne :
Indic Indic Indic Zone Facteur1 Code opération Zone facteur 2 Zone résultat Indic Indic Indic
cond cond cond resul résul résul
HT ADD TVA TTC
Signalons au passage que les noms de zone ne doivent pas dépasser 6 caractères
en GAP.
On peut aussi additionner une constante, par exemple, pour ajouter 100 francs de
port à un montant appelé MONT :
MONT ADD 100 MONTNT
Une variante de l'ordre ADD se révèle parfois être bien pratique.

Il s'agit de l'ordre Z-ADD qui commence par placer le nombre 0 dans la zone
résultat, puis qui ajoute à ce 0 la zone facteur 2.
Ce qui donne par exemple :
Z-ADD 5 X

Le résultat est tout simplement que la zone X contiendra le nombre 5 après le Z-
ADD.
D'autres opérations arithmétiques existent en GAP. Ce sont :
- la soustraction SUB avec sa variante Z-SUB;

- la multiplication MULT;
- la division DIV;
- le calcul de racine carrée SQRT;
- la récupération du reste d'une division par MVR.
Vous trouverez, en annexe 3, des exemples d'opérations arithmétiques.
Vous aurez certainement l'occasion de les utiliser. S'il est inutile que vous les
étudiez à fond maintenant, sachez les retrouver plus tard par vous-même, puisque
leur description se trouve dans le livre RPG/400 REFERENCE. Ce sera un
excellent exercice d'auto-apprentissage, d'anglais, et de GAP !
4.5.2. Ordre MOVE
Copie le contenu d'une zone mémoire dans une autre zone mémoire.
Par exemple, pour mettre le montant TTC calculé ci-dessus dans la zone
APAYER, il suffit d'écrire l'ordre suivant :
MOVE TTC APAYER
Attention au cas où les zones facteur 2 et résultat sont de longueur différentes.

L'ordre MOVE cadre les données à droite, et ne complète pas à gauche par des
blancs, comme le font beaucoup de langages. Par exemple :
Zone Facteur 2 = 'ABCD'

Zone Résultat avant le MOVE = '123456'
Zone Résultat après le MOVE = '12ABCD'
Ou encore :
Zone Facteur 2 = 'ABCDEFGH'

Zone Résultat avant le MOVE = '123456'
Zone Résultat après le MOVE = 'CDEFGH'
L'ordre MOVE convient parfaitement pour copier des données numériques, mais
beaucoup moins bien pour des données alphanumériques (de type caractères).

En effet , l'ordre MOVE aligne les données à droite, ce qui convient au
numérique, mais pas à l'alphanumérique, qui doit être aligné à gauche.
4.5.3. Ordre MOVEL
Remplacer dans ce cas simplement le code opération MOVE par le code opération
MOVEL qui signifie MOVE LEFT (à gauche). Par exemple, pour copier NOM1
dans NOM2 :
MOVEL NOM1 NOM2
Au cas où les zones émettrices et réceptrices d'un MOVEL sont de longueur

différentes, vous retrouverez sensiblement les mêmes problèmes. Par exemple :
Zone Facteur 2 = 'ABCD'

Zone Résultat avant le MOVEL = '123456'
Zone Résultat après le MOVEL = 'ABCD56'
Ou encore :
Zone Facteur 2 = 'ABCDEFGH'

Zone Résultat avant le MOVEL = '123456'
Zone Résultat après le MOVEL = 'ABCDEF'
Pour convertir des zones numériques en zones caractères, faire attention au signe
qui occupe le dernier demi-octet le plus à droite des zones numériques, et faussera
le dernier chiffre de la zone résultat.
Attention, ni le MOVE ni le MOVEL ne tiennent compte de l'alignement sur la

virgule décimale.
Voici d'autres exemples dans lesquels les zones déclarées en caractère sont entre
quotes, celles déclarées en numérique ne le sont pas. Rappelons que les quotes
sont des apostrophes simples, alors que l'on trouve souvent en micro-informatique
des apostrophes doubles :
- la position de la virgule n'est pas respectée par le MOVEL :
Zone Facteur 2 = 123,45

Zone Résultat avant le MOVEL = 6,7890
Zone Résultat après le MOVEL = 1,2345

- le signe est respecté :
Zone Facteur 2 = -123,4

Zone Résultat avant le MOVEL = 567,8
Zone Résultat après le MOVEL = -123,4
- le signe contenu dans le demi-octet de droite d'une zone numérique donne

des résultats bizarres après un transfert dans une zone caractères, c'est
simplement le résultat de la conversion en EBCDIC :
Zone Facteur 2 = -12345

Zone Résultat avant le MOVEL = 'ABCDE'
Zone Résultat après le MOVEL = '1234N'
4.5.4. La déclaration automatique des zones mémoire
Nous venons de parler de zones déclarées en type caractère ou bien en type

numérique. Voyons comment se passe la déclaration des zones.
En GAP, les zones mémoire que vous êtes amené à utiliser dans un programme
sont déclarées (c'est-à-dire réservées) automatiquement. Lorsque le compilateur
GAP rencontre un nouveau nom de zone qu'il n'a pas encore rencontré depuis le
début du programme, il lui réserve automatiquement un emplacement en mémoire
qui portera le nom de cette zone. Dans d'autres langages tels que le COBOL, la
déclaration est à faire explicitement. En dBASE, la déclaration est, comme en
GAP, implicite.
Cependant, le compilateur GAP, bien que très intelligent, ne peut deviner ni le

type de zone (numérique ou caractère), ni la longueur de la zone que vous utilisez.
Par conséquent, il est obligatoire, lors de la première utilisation d'une zone

mémoire, en principe dans la colonne facteur résultat d'une spécification C, de
spécifier le type et la longueur de la nouvelle zone.
Il suffit pour cela d'indiquer la longueur de la zone en colonnes 49 à 51, en

l'alignant à droite, ainsi que le nombre de décimales en colonne 52. La longueur
de la zone comprend aussi les décimales après la virgule. La virgule elle-même
n'est en revanche pas à prendre en compte dans la longueur de la zone.
Le compilateur fait la différence entre zone numérique et zone alphanumérique

(ou caractère) d'après le contenu de la colonne 52.
Si celle-ci est vide, il considère qu'il s'agit d'alphanumérique, sinon, il prend la
zone résultat en numérique.
Cela signifie que, dans le cas d'une zone numérique entière (sans décimales), il
faut impérativement mettre un zéro en colonne 52.

Reprenons l'exemple déjà vu dans l'addition, mais en supposant maintenant que la
zone mémoire APAYER n'est encore jamais apparue dans le programme. Cette
zone doit pouvoir contenir des sommes allant jusqu'à 99999,99 francs.
MOVE TTC APAYER 72
La longueur totale est de 7, et il y a 2 décimales.
Il est bien entendu que ce système de déclaration automatique des zones mémoire
ne concerne absolument pas les rubriques des enregistrements dans les fichiers.
Elles sont, elles aussi, déclarées automatiquement dans les programmes, mais par
le simple moyen des spécifications F que nous avons déjà vues.
Toute spécification F engendre donc automatiquement la réservation en mémoire
d'autant d'emplacements que de rubriques dans le fichier.
ATTENTION tout de même à une particularité importante du GAP :
Si deux rubriques de deux fichiers différents portent le même nom, elles ne

donneront lieu qu'à une seule zone en mémoire.
Par exemple, si votre programme utilise le fichier ARTICLE contenant la rubrique

CODEAR, et que ce même programme utilise aussi le fichier MOUVE contenant
une rubrique portant le même nom CODEAR, vous n'aurez dans ce cas qu'une
seule zone en mémoire nommée CODEAR.
On ne retrouve pas cette particularité dans les autres langages, elle est à la fois très
puissante car elle évite des MOVE et très dangereuse si on l'oublie.

4.6. L'ordre de lecture séquentielle
4.6.1. Ordre READ de lecture séquentielle d'un fichier
Passons maintenant au traitement des fichiers.
Comme nous l'avons vu précédemment, tout fichier utilisé dans un programme

GAP doit donner lieu à une spécification F, même s'il s'agit d'un fichier
imprimante ou d'un fichier écran.
Une fois ces spécifications F exécutées, le compilateur GAP, réserve

automatiquement, comme nous en avons déjà parlé, un emplacement en mémoire
pour chaque rubrique de chaque fichier déclaré par une spécification F.
Dès lors, vous pouvez demander la lecture d'un enregistrement par le simple code
opération READ. Il n'y a pas besoin de rédiger d'ordre d'ouverture du fichier
comme dans beaucoup de langages. L'ordre READ lit sur disque le prochain
enregistrement (ou le premier enregistrement s'il s'agit de la première lecture).
Notons au passage que vous disposez en GAP de l'ordre :
READP
qui signifie "read prior record", c'est-à-dire : lire l'enregistrement précédent. C'est
donc l'équivalent de l'ordre READ, mais en "marche arrière".
Repassons la "marche avant". A l'exécution d'un ordre READ, les rubriques de

l'enregistrement suivant viendront se recopier du disque dur vers les zones
mémoire dont nous avons vu la déclaration automatique ci-dessus.
Voici un exemple d'ordre READ :
READ ARTICLE 91
Le code opération READ se trouve bien sûr dans la colonne Code Opération. Le
nom du fichier doit se trouver dans la colonne Zone facteur 2. Et on trouve en
colonnes 58 et 59 un indicateur résultat.
Rappelons que les indicateurs sont des variables binaires qui sont l'une des
originalités du GAP. Ces indicateurs sont identifiés par leur numéros de 01 à 99.
Cependant, nous verrons prochainement qu'avec certains codes opération ils
devront être identifiés d'une manière sensiblement différente.

On appellera par exemple l'indicateur 03 de la façon suivante :
*IN03
N'oubliez pas l'astérisque ! Nous allons y revenir.
Dans le cas de l'ordre READ, GAP mettra le chiffre binaire '1' dans l'indicateur
dont vous aurez spécifié le numéro en colonnes 58 et 59, uniquement si l'on est
arrivé en fin de fichier, et donc s'il n'est plus possible de lire d'enregistrement
suivant.
Dans tous les autres cas, l'indicateur en question restera à '0'.
C'est grâce à cet indicateur que vous allez pouvoir ensuite tester pour savoir si oui
ou non vous êtes arrivé à la fin de votre fichier.
Pour faciliter la maintenance des programmes, je préconise habituellement une

norme d'utilisation des indicateurs. Ainsi tous les programmeurs de l'entreprise
utilisent les mêmes numéros d'indicateurs pour les mêmes conditions. Bien sûr,
cette norme n'est absolument pas imposée par le langage GAP, mais elle
standardise vos programmes. Elle vous est proposée en annexe 4. Vous y verrez
que les indicateurs 91 à 99 y sont affectés aux conditions de fin de fichier.
Maintenant que nous savons lire un fichier, nous pouvons aborder la structure
répétitive, au sein de laquelle nous pourrons placer, à titre d'exemple, un ordre
READ.

4.7. Les ordres de structure
4.7.1. Ordre DOWxx : la structure répétitive
La structure répétitive suivante :
TANT QUE A=B
ordre 1
ordre 2
ordre 3
FIN DU TANT QUE
se programme en GAP ainsi :
A DOWEQ B
ordre 1
ordre 2
ordre 3
END
Bien sûr, il faudra remplacer "ordre1", "ordre 2" et "ordre 3" par les ordres GAP
souhaités. L'ordre de structure TANT QUE se traduit par DOW, ce qui signifie
"Do While" (= faire tant que). La condition d'égalité se traduit par les 2 lettres qui
suivent DOW.
Ces 2 lettres peuvent être :
EQ signifie "equal" = égal

NE signifie "not equal" = non égal
GT signifie "greater than" = strictement
supérieur à
GE signifie "greater or equal" = supérieur ou égal à
LT signifie "less than" = strictement inférieur à
LE signifie "less or equal" = inférieur ou égal à
On mettra dans les zones facteurs 1 et 2 les deux noms des zones à comparer. Ces
deux facteurs doivent être de même type : tous deux numériques ou alors tous
deux alphanumériques.

L'un des deux facteurs peut être une constante. On peut par exemple être amené à
comparer la rubrique SEXE avec la constante 'F'. Les constantes numériques
doivent, comme dans tous les langages, être écrites sans quotes, alors que les
constantes alphanumériques doivent être écrites entre quotes.
Voici quelques exemples d'ordres DOW valides (les instructions de la structure

répétitive ainsi que les ordres END ne sont pas codés ci-dessous) :
A DOWEQ 2
B DOWNE 'ABCD'
C DOWGT '123'
D DOWLE 123
A et D sont des zones numériques, B et C sont alphanumériques (c'est-à-dire de

type caractère).
On notera que l'indentation (c'est-à-dire le décalage vers la droite) des instructions

comprises entre le "tant que" et le "fin du tant que" n'est pas possible en GAP,
étant donné l'obligation de respecter le colonnage des spécifications C.
Dommage !
Voici maintenant un exemple de structure répétitive qui lit tout un fichier, du

premier au dernier enregistrement. Notez que ce morceau de programme ne fait
que lire les enregistrements et les compter, mais n'affiche pas ou n'imprime pas le
résultat du comptage. Cela peut paraître absurde, mais nous n'avons pas encore
appris comment imprimer ou afficher à l'écran une zone mémoire !
Z-ADD 0 NOMBRE 60
READ ARTICLE 91
*IN91 DOWEQ '0'
NOMBRE ADD 1 NOMBRE
READ ARTICLE 91
END
Il est important que vous compreniez bien ce premier "bout" de programme.
La première instruction Z-ADD sert à réserver la zone en mémoire qui servira de

compteur (on dit aussi "déclarer une zone") et y mettre le nombre 0. Cette remise

à zéro paraît normale pour un compteur. Que diriez-vous d'une voiture neuve
ayant déjà 82659 kilomètres ?
Ce compteur, que l'on a choisi d'appeler NOMBRE, a été déclaré ici en tant que
zone numérique d'une longueur de 6 chiffres, sans décimale, évidemment.
Rappelons qu'il est obligatoire de préciser ainsi la longueur de toute zone mémoire
que l'on utilise pour la première fois.
La deuxième instruction est un READ qui sert à faire une première lecture du
fichier ARTICLE avant d'entrer dans la boucle répétitive. Ainsi, si le fichier est
vide, ce qui peut toujours arriver, on n'entrera même pas dans la répétitive.
J'ose croire que vous connaissez les principes de la programmation structurée que
j'utilise ici. Cette méthode, aujourd'hui indispensable, est devenue un véritable
label de qualité des logiciels.
Remarquez que l'indicateur 91 sera positionné à '1' en fin de fichier (c'est-à-dire ici
si le fichier est vide, puisque c'est la première lecture), et à '0' dans le cas
contraire.
La troisième instruction est le DOW . La condition de répétition est ici : "tant que
l'indicateur 91 est à 0". Notez que l'indicateur doit être identifié par son nom
complet, c'est-à-dire *IN91, et qu'il est comparé au chiffre binaire '0', qui doit être
entouré par des simples quotes. Il en va ainsi des chiffres binaires '0' et '1'.
Nous avons ensuite l'incrémentation (c'est-à-dire l'augmentation) du compteur

NOMBRE . Il n'y a plus ici à rappeler la longueur de la zone NOMBRE,
puisqu'elle a déjà été déclarée au-dessus. La constante 1 n'est pas entre quotes, car
il s'agit d'une constante numérique normale (en base 10, en non en base 2 comme
les constantes binaires qui doivent être entre quotes).
En fin de répétitive, nous avons un nouvel ordre READ, le même que le premier,
avec son indicateur 91, qui permet de passer à l'enregistrement suivant et qui
déclenchera la sortie de la boucle dès qu'on arrivera en fin de fichier.
Voici un petit exercice. Vous trouverez son corrigé, comme tous les corrigés des
exercices de ce livre, en annexe 5.

EXERCICE 1
Ecrire un programme (sur papier pour l'instant, ne le saisissez pas) qui incrémente
un compteur de 3 en 3, en partant du nombre 1 000 pour aller jusqu'à 2 000.
Ce compteur contiendra donc successivement les valeurs suivantes :
1 000
1 003
1 006
1 009
etc.
Ce programme n'a bien sûr pas plus d'utilité que celui que nous venons de voir,
hormis son intérêt pédagogique.

4.7.2. Ordre IFxx : la structure alternative
Soit à traduire en GAP la structure alternative suivante :
Si A = B
ordre 1
ordre 2
ordre 3
Sinon
ordre 4
ordre 5
ordre 6
Fin du si
Nous écrirons en GAP :
A IFEQ B
ordre 1
ordre 2
ordre 3
ELSE
ordre 4
ordre 5
ordre 6
END
Le "Si" est donc traduit par IF suivi, comme dans le DOW, par EQ, NE, GT, GE,
LT ou LE.
Les facteurs 1 et 2 contiennent les zones à comparer (comme dans le DOW).
Le mot ELSE traduit le "Sinon".
Le mot END traduit le "Fin du Si". C'est le même ordre que celui qui marque la
fin d'un "Tant que".

Il se peut, lorsque l'on ne programme pas en méthode structurée "pure", que le
pavé du "Sinon" soit vide, dans ce cas on supprimera purement et simplement
l'ordre ELSE.
Dans notre exemple, si les ordres ORDRE4, ORDRE5, ORDRE6 n'existent pas,
cela donnera :
A IFEQ B
ordre 1
ordre 2
ordre 3
END

EXERCICE 2
Supposons que, dans un programme de facturation, nous ayons stocké le montant
à payer dans une zone mémoire nommée MONT1.
Ecrire, toujours sur papier, le morceau de programme qui ajoute 100 F de port à
MONT1 si MONT1 est inférieur ou égal à 10 000 F , et qui fait une réduction de 5
pour 100 dans le cas inverse.
EXERCICE 3
Les règles de l'exercice précédent évoluent.
La règle des frais de port reste inchangée, mais la réduction de 5 pour 100 ne
s'applique désormais qu'aux montants strictement supérieurs à 50 000 F.
Donc, ni frais de port ni réduction entre 10 000 F et 50 000 F.

4.7.3. Autre programmation des alternatives
On dispose en GAP d'une autre façon de programmer les alternatives, qui paraît
beaucoup plus simple.
Attention : cela ne concerne que les alternatives dont la condition est composée
d'un ou plusieurs indicateurs. Cette technique ne sera donc pas utilisable pour des
conditions faisant intervenir des zones de mémoire ou des zones de fichier de type
caractère ou numérique.
La technique des alternatives par indicateurs consiste à écrire, en tête des lignes
que l'on veut conditionner, le ou les numéros des indicateurs dans les colonnes
"Indicateurs de condition", c'est-à-dire dans les colonnes 10 et 11, 13 et 14, 16 et
17. De plus on pourra inverser les conditions en placant la lettre "N" dans une des
colonnes 9, 12 ou 15.
Ce qui donnera par exemple :
02 ordre 1
12 26 ordre 2
16 05 01 ordre 3
N06 ordre 4
09 N28 ordre 5
L'ordre 1 ne sera exécuté que si l'indicateur 02 est à '1'.
L'ordre 2 ne sera exécuté que si les indicateurs 12 et 26 sont à '1'.
L'ordre 3 ne sera exécuté que si les indicateurs 16, 05, et 01 sont à '1'.
L'ordre 4 ne sera exécuté que si l'indicateur 06 est à '0'. Le N inverse la condition.
L'ordre 5 ne sera exécuté que si l'indicateur 09 est à '1' et que l'indicateur 28 est à
'0'.
On voit que l'écriture de ces alternatives est plus légère qu'en utilisant l'ordre IF.

4.7.4. Ordres SETON et SETOFF
Pour mettre une valeur '0' ou '1' dans un indicateur, vous ne pouvez pas utiliser
l'ordre MOVE vu plus haut, car il ne fonctionne que pour les données numériques
décimales ou les données de type caractère, mais pas pour les indicateurs.
Vous devez utiliser les ordres SETON et SETOF, dont vous trouverez des
exemples ci-dessous :
Indic Indic Indic Zone Facteur1 Code opération Zone facteur 2 Zone Indic Indic Indic
cond cond cond résultat resul résul résul
SETON 05
SETOF 09
SETON 12 01 25
Le premier SETON met un '1' binaire dans l'indicateur 05.
Le SETOF suivant met un '0' binaire dans l'indicateur 09.
Le dernier SETON met en un seul ordre des '1' binaires dans les indicateurs 12, 01
et 25.

EXERCICE 4
Vous êtes embauché dans une société d'intérim pour remplacer un programmeur
surmené tombé malade.
Ce pauvre programmeur a commencé un programme dans lequel il s'est déjà

occupé de mettre les indicateurs suivants à 0 ou à 1 selon le cas :
Indicateur 05 = '1' si salaire > 5 000

Indicateur 10 = '1' si cadre
Indicateur 11 = '1' si cadre supérieur
Vous devez continuer ce programme, en calculant le montant de la prime de la

façon suivante:
si salaire <ou = 5 000 alors prime = 1 000

si salaire > 5 000 alors prime = 500
si salaire > 10 000 et cadre alors prime = 400
si salaire compris entre 10 000 et 15 000 et cadre sup alors prime = 2 600
Les primes peuvent parfois se cumuler.
Vous utiliserez d'abord la technique classique des IF.
Exercice 5
Puis vous réécrirez ce même morceau de programme en utilisant les indicateurs.

Comparez les deux techniques.

4.8. Les sous-programmes
4.8.1. Les sous-programmes internes
Si l'on veut programmer en programmation structurée pure, il est possible de

regrouper tous les ordres d'un pavé dans un sous-programme.
Voici deux façons de programmer le même algorithme, d'abord en structuré que je

qualifierai d'optimisé, puis en structuré pur.
En structuré optimisé :
ordre 1
ordre 2
Tant que condition
ordre 3
ordre 4
Fin du tant que
ordre 5
ordre 6
En structuré pur:
exécuter sous-programme 1
Tant que condition
Fin du tant que
Début du sous-programme 1
ordre 1
ordre 2
Fin du sous-programme
ordre 3
ordre 4
ordre 5
ordre 6

La seule différence entre les deux méthodes est l'utilisation des sous-programmes.
En GAP, l'ordre "exécuter sous-programme" s'écrit EXSR , ce qui vient de
"Execute Sub-routine".
L'ordre "Début de sous-programme" s'écrit BEGSR, c'est-à-dire "Beginning of

sub-routine".
L'ordre "Fin de sous-programme" s'écrit ENDSR, c'est-à-dire "End of sub-

routine".
Ce qui donnera en GAP :
EXSR PAVE1
A DOWEQ B
EXSR PAVE2
END
EXSR PAVE3
PAVE1 BEGSR
ordre 1
ordre 2
ENDSR
PAVE2 BEGSR
ordre 3
ordre 4
ENDSR
PAVE3 BEGSR
ordre 5
ordre 6
ENDSR
Les sous-programmes 1,2 et 3 ont été ici appelés PAVE1, PAVE2 et PAVE3.
Les sous-programmes internes doivent être écrits de préférence en fin de

programme, le programme n'en sera que plus clair.

EXERCICE 6
Ecrivez en structuré pur un programme qui compte le nombre de salariés féminins

de l'entreprise, et qui calcule en même temps le total des salaires de tous les
hommes.
Ici encore, les zones compteur et total resteront malheureusement en mémoire,

puisque nous ne savons encore ni les imprimer sur papier ni les afficher sur écran.
Le fichier du personnel s'appelle PERS.
Ses enregistrements contiennent les rubriques suivantes :
PMAT matricule sur 4 caractères

PNOM nom sur 20 caractères
PPRE prénom sur 15 caractères
PSEX "H" ou "F"
PSAL salaire sur 7 chiffres dont 2 après la virgule
PSER code du service sur 2 caractères
Vous trouverez le corrigé de cet exercice en annexe 5, ainsi que sa version en

programmation structurée optimisée. Comparez les deux solutions, et faites-vous
une religion. Non, non, je ne cherche pas à manipuler le lecteur !

4.8.2. Les sous-programmes externes
En GAP, l'ordre CALL permet à tout moment d'un programme A d'appeler un
autre programme B, indépendant de A. Le programme B peut être écrit dans
n'importe quel langage installé sur l'AS/400, y compris en langage de contrôle CL.
Cela offre donc la possibilité d'exécuter n'importe quelle série d'ordres CL à partir
d'un programme GAP.
Un exemple d'ordre CALL :
CALL 'SPROB'
PARM ADATE
PARM ANOM
Le nom du sous-programme doit se trouver en zone facteur 2. Il peut être écrit

entre quotes comme ci dessus, ou bien sous forme d'un nom de zone
préalablement rempli avec le nom du sous-programme.
Il peut arriver, comme dans l'exemple ci-dessus, que l'on doive transmettre des
paramètres au sous-programme. C'est le rôle des ordres PARM écrits juste après
l'ordre CALL.
D'autre part, si dans le sous-programme on désire revenir dans le programme

appelant, il suffira d'écrire dans le sous-programme l'ordre :
RETRN

4.9. Les ordres d'entrée-sortie
Nous avons déjà vu l'ordre de lecture READ , mais de nombreux ordres d'entrée-
sortie restent à étudier.
4.9.1. Ordre WRITE : l'écriture dans un fichier disque
Pour ajouter un nouvel enregistrement dans un fichier disque, il faut :
- avoir déclaré ce fichier dans une spécification F;

- avoir mis "O" ou "U" en colonne 15 de cette spécification F (comme Output ou
Update);
- avoir mis "A" (comme "Add") en colonne 66 de cette spécification F.
Il faut ensuite mettre les données dans les rubriques adéquates du fichier en
effectuant par exemple des MOVE. Attention, ces MOVE ne modifient en rien le
fichier sur disque, ils n'opèrent de changements qu'en mémoire.
Alors seulement vous pouvez écrire un ordre WRITE pour créer effectivement un
nouvel enregistrement sur disque. Les rubriques de cet enregistrement seront
égales à ce que vous aurez préalablement placé dans les rubriques équivalentes en
mémoire.
Prenons par exemple l'écriture d'un enregistrement du fichier ARTICLE. Chaque

enregistrement contient les 3 rubriques suivantes :
- CODE
- LIBE
- PRIX
Le CODE et le libellé LIBE viennent des zones mémoire ECODE et ELIBE, et le

prix est fixé à 150 francs.
ECODE et ELIBE peuvent par exemple venir d'une saisie à l'écran, mais à notre
niveau, peu importe.
Donc, avant de faire l'écriture, il faut mettre ECODE dans CODE, ELIBE dans
LIBE et 150 dans PRIX.
MOVEL ECODE CODE

MOVEL ELIBE LIBE
Z-ADD 150 PRIX
WRITE ARTICLE

4.9.2. Ordre WRITE : l'écriture sur imprimante
Supposons que nous ayons à programmer l'état suivant :
LISTE DES SALARIES DU SERVICE : XXXXXXXXX
MATRICULE NOM SALAIRE
XXXX XXXXXXXXXXXXXXXX XXXXXXX

Total : XXXXXXX
Pour imprimer cet état, nous devrons imprimer successivement 3 ensembles de

données :
- l'en-tête de l'état qui comprend les deux premières lignes

("LISTE DES SALARIES..." et "MATRICULE NOM SALAIRE")
à imprimer 1 seule fois en début de programme;
- la ligne concernant un salarié à imprimer autant de fois que de salariés;
- la ligne finale de total à imprimer 1 seule fois en fin de programme.
Lorsque nous décrirons le fichier d'impression à l'extérieur du programme dans les

fameuses SDD que nous étudierons dans le chapitre suivant, nous définirons trois
ensembles de données à imprimer; ces ensembles s'appellent des formats
d'impression:

- le format de l'en-tête de l'état qui sera baptisé ENTET;
- le format d'une ligne salarié qui sera baptisé LIGNE;
- le format de fin d'état qui sera baptisé TOTAL.
Dans le programme GAP, pour imprimer par exemple le format d'en-tête, il nous
suffira de faire comme pour écrire un enregistrement de fichier disque; c'est-à-
dire:
- remplir les rubriques correspondant aux variables du format d'impression d'en-

tête;
- écrire un ordre WRITE en mettant en facteur 2, non pas le nom du fichier, mais
le nom du format d'en-tête, qui aura été spécifié dans les SDD.
Même chose pour les deux autres formats.
On fera donc un seul WRITE du format d'en-tête (dans le pavé de début de

programme) pour imprimer l'en-tête, puis autant de WRITE du format de ligne
que de salariés (dans la répétitive sur salarié), et enfin, un seul WRITE du format
de fin d'état (dans le pavé de fin de programme).
Voici les trois ordres WRITE. Bien sûr, il ne faudra pas les programmer à la file
tels quels, mais les insérer au bon endroit avant, dans, et après le "do while", et il
faudra aussi insérer des ordres de remplissage des rubriques à imprimer :
WRITE ENTET
WRITE LIGNE
WRITE TOTAL
Je ne vous donne pas ici le programme d'impression complet, car ce sera l'objet de
l'exercice suivant !

4.9.3. Ordre CHAIN : la lecture directe d'un enregistrement
Nous avons vu pour l'instant la lecture séquentielle d'un fichier avec l'ordre
READ. Mais il existe une autre façon d'accéder à un fichier, c'est l'accès direct,
beaucoup plus puissant.
Faisons une petite comparaison.

Habituellement, un roman se lit séquentiellement. Certains fichiers informatiques
se lisent aussi séquentiellement. Par exemple, lorsque l'ordinateur fait la paie du
personnel, il traite les salariés du fichier du personnel séquentiellement, en
essayant de préférence de ne pas en oublier.
Mais si vous voulez accéder à un article d'une encyclopédie, il n'est pas vraiment
rapide de lire l'encyclopédie séquentiellement depuis la page 1 jusqu'à l'article qui
vous intéresse !
C'est la raison pour laquelle les encyclopédies ont un index (attention, ce mot est
important) qui vous adresse (celui-là aussi) directement à la page de l'article
voulu.
En informatique, pour afficher sur écran le stock disponible d'un article, on ne va

surtout pas choisir l'accès séquentiel au fichier article.
Surtout si le fichier a 100 000 enregistrements et que l'on cherche le 90 000e !
On préférera l'accès direct, infiniment plus rapide.
Mais en informatique, comme dans le domaine des livres, on ne peut faire un

accès direct que si un index existe.
Dans notre encyclopédie, l'index est constitué de la liste des thèmes.

Dans le fichier des articles, l'index est constitué de la liste des références des
articles du fichier classée par ordre alphabétique. En face de chaque référence, on
trouvera l'adresse de l'enregistrement correspondant. La référence article
s'appellera la "clé d'index" du fichier.
L'index est donc une table de correspondance entre toutes les clés classées par
ordre alphabétique (ou numérique) et les adresses des enregistrements qui leur
correspondent. Ainsi, connaissant l'adresse de l'enregistrement, on va le lire
directement, sans devoir lire tous ceux qui précèdent. Voilà pourquoi c'est plus
rapide.
Ce n'est pas plus compliqué que cela.
La grosse majorité des fichiers sur une machine telle que l'AS/400 sont
d'organisation indexée. Cela prend plus de place (à cause de l'index) mais c'est
tellement plus rapide.

Voyons donc maintenant comment accéder en direct à un fichier d'organisation
indexée. Votre fichier doit avoir été déclaré par une spécification F en n'oubliant
pas le K en colonne 31, qui signifie "Key", c'est-à-dire Clé.
Pour lire un enregistrement du fichier ARTICLE connaissant la référence de

l'article qui aura été placée (peu importe ici comment) dans la zone mémoire
appelée CLEART, il suffira d'écrire ce qui suit :
CLEART CHAIN ARTICLE 81
On place donc la clé en zone facteur 1, le code opération CHAIN pour faire une
lecture directe, le nom du fichier en zone facteur 2, et enfin un numéro
d'indicateur en zone indicateur résultat 1, c'est-à-dire en colonnes 54 et 55.
Cet indicateur sera positionné à '1' si l'enregistrement n'existe pas, ce qui peut fort
bien arriver, il sera à '0' si l'enregistrement existe. On pourra donc programmer
ensuite une alternative en se servant de cet indicateur dans la condition de
l'alternative.
En ce qui concerne le choix du numéro de l'indicateur, tout numéro compris entre

01 et 99 convient, mais... nous insistons à nouveau sur la nécessité d'une
normalisation des indicateurs (cf annexe 4), pour faciliter la communication entre
analystes-programmeurs et pour faciliter la maintenance.
En conséquence, nous vous demandons d'utiliser les numéros 81 à 89 pour les

indicateurs de clé non trouvée.

4.9.4. Ordre DELET
L'ordre DELET sert à supprimer un enregistrement d'un fichier bases de données.
Il s'agit d'une suppression physique de l'enregistrement, et non d'une suppression
logique qui permettrait de réactiver l'enregistrement plus tard, si besoin était. Ici,
l'enregistrement est totalement et irrémédiablement détruit.
L'ordre DELET ne fonctionne que pour les fichiers ayant un U (comme "update" =
mise à jour) en colonne 15 de la spécification F.
Si la zone facteur 1 est vide, c'est l'enregistrement en cours qui est supprimé.
Si la zone facteur 1 contient le nom de clé de l'enregistrement, la clé sera

recherchée dans le fichier, puis l'enregistrement sera supprimé. Dans ce cas, un
numéro d'indicateur doit être spécifié en colonnes 54 et 55, il sera positionné à '1'
par l'ordre DELET si l'enregistrement concerné n'existe pas, ou bien n'est pas
disponible.
La zone facteur 2 doit contenir le nom du fichier.
Exemple :
REFART DELET FARTIC 81
4.9.5. Ordre UPDAT

Cette instruction modifie un enregistrement d'un fichier. Tout l'enregistrement est
réécrit, il est donc impossible de ne réécrire qu'une rubrique de l'enregistrement.
L'enregistrement réécrit est l'enregistrement en cours, donc précédemment lu par

un READ ou par un CHAIN.
Au moins une des rubriques de cet enregistrement aura été vraisemblablement

modifiée par le programme entre l'ordre de lecture et l'ordre UPDAT.
La zone facteur 1 doit être blanche.

La zone facteur 2 doit contenir le nom du format d'enregistrement du fichier
concerné (voir la notion de format d'enregistrement dans le chapitre traitant des
fichiers bases de données).
Les 3 zones d'indicateurs résultat restent à blanc.
Exemple :

READ PERS 91
N91 ADD 1000 SALAIR
N91 UPDAT PERSF1
4.9.6. Ordre SETON LR : l'arrêt du programme
Attention, pour que votre programme puisse s'arrêter correctement à la fin de

l'exécution,vous devez impérativement positionner un indicateur très particulier à
'1'.
C'est l'indicateur appelé : LR ce qui signifie "Last Record" = dernier

enregistrement.
Pour ce faire, n'oubliez pas d'écrire de préférence en fin de programme l'ordre

suivant :
SETON LR
Voici maintenant un petit exercice de synthèse qui met en pratique ce que nous
venons de voir.

EXERCICE 7
Ecrire le programme qui imprime la liste des salariés dessinée ci-dessus.
On se servira du fichier PERS de l'exercice précédent.
On suppose que les SDD du fichier imprimante existent déjà et qu'elles définissent
3 formats d'impression.
- le format d'en-tête ENTET contenant la rubrique :
ENOS Nom du service sur 9 caractères
- le format de ligne LIGNE contenant les rubriques :
EMAT Matricule sur 4 caractères

ENOM Nom du salarié sur 16 caractères
ESAL Salaire sur 7 chiffres dont 2 après la virgule
- le format de fin d'état FIN contenant la rubrique :
ETOT Total des salaires
Le service à imprimer sera le service "B5" uniquement. Il faudra donc ne

sélectionner que celui-là.
On ira rechercher en accès direct le nom du service (qui doit être imprimé en en-
tête d'état) dans le fichier SERV dont les enregistrements ont la structure suivante
:
SCOD code service sur 2 caractères

SNOM nom du service sur 9 caractères
On vous demande, au cas où le code service ne figurerait pas dans le fichier

SERV, d'arrêter le programme sans rien imprimer.
Nous arrivons au terme de l'apprentissage des ordres GAP de base. Mais nous
espérons vous avoir mis en appétit pour aller plus loin avec le GAP.

5. Les SDD des fichiers
d'impression
5.1. Le principe des SDD
Avec l'OS/400, les descriptions de fichiers sont mémorisées à l'extérieur du

programme, et non à l'intérieur, comme c'était le cas dans les générations
précédentes de systèmes d'exploitation.
Cependant, il reste possible de travailler "à l'ancienne" en définissant les fichiers à

l'intérieur des programmes, cela pour que les anciens programmes restent
compatibles avec l'AS/400.
Il est important de préciser que le principe de déclaration externe des fichiers est
le même pour les types de fichiers :
- les fichiers de données;

- les fichiers d'impression;
- les fichiers écran.
Pour créer un fichier d'impression, il vous faudra passer par les 3 étapes suivantes:
- rédiger sur papier les SDD de ce fichier impression;
- saisir ces SDD à l'aide de l'éditeur de source SEU (que vous avez déjà utilisé
pour saisir du langage source GAP);
- compiler ces SDD pour créer réellement le fichier d'impression.
Détaillons ces trois phases.
5.2. La syntaxe des SDD d'impression
Les spécifications de description de données (SDD) des fichiers d'impression

servent à décrire les différentes parties de votre état. Si nous voulons imprimer
une facture, il faudra la découper en plusieurs sous-ensembles :

- l'ensemble des lignes qui composent l'en-tête de facture avec le numéro de
facture, la date, etc.;
- la ligne de détail de facture: référence, désignation, quantité, prix ; elle se répéte

autant de fois que le nombre d'articles facturés;
- l'ensemble des lignes qui composent le bas de facture avec tous les totaux, la
TVA, le montant TTC, etc.
Chacun de ces sous-ensembles donnera lieu à ce qu'on appelle un format

d'impression.
Nous aurons donc ici les trois formats d'impression, que nous nommerons par
exemple :
- DEBUT
- LIGNE
- FIN
Chacun des formats est composé d'une ou de plusieurs lignes.

Les formats DEBUT et FIN contiendront vraisemblablement plusieurs lignes,
mais le format LIGNE s'imprimera sur une ligne seulement.
Rédiger des SDD consiste à décrire à l'ordinateur d'abord la liste des formats
d'impression. Puis, pour chacun des formats, on décrira la liste des champs qu'il
contient avec l'emplacement de chaque champ sur l'état (numéro de ligne et de
colonne).
En plus des spécifications de formats et des spécifications de champs, on pourra

donner des spécifications qui concerneront l'ensemble du fichier d'impression.
Il y aura donc trois niveaux de spécifications dans les SDD :
- les spécifications que l'on écrit au niveau du fichier d'impression lui-même;
- les spécifications que l'on écrit au niveau de chaque format d'impression;
- les spécifications que l'on écrit au niveau de chaque champ d'impression.
Récapitulons.
Lorsque l'on définit un fichier d'impression on écrira : une SDD pour les
spécifications générales concernant le fichier d'impression dans sa globalité. Cette
ligne sera facultative s'il n'y a pas de spécification particulière à indiquer.
On écrira en plus : une et une seule SDD par format d'impression.

Puis, au sein de chaque format d'impression, on écrira encore : une et une seule
SDD par champ, que ce soit un champ constant ou un champ variable.
Toutefois, nous verrons par la suite que ce que nous venons d'appeler une SDD
peut parfois être constitué d'une ligne principale, et d'une ou de plusieurs lignes
suite, s'il n'y a pas assez de place sur la ligne principale.
Vous trouverez ci-dessous un exemple complet de SDD définissant un fichier

d'impression :
A/O/* Ind 1 Ind 2 Ind 3 Type Nom Réfé Long Type Posit. Usage Ligne Col. Fonctions
SDD donn. décim
7 8 11 14 17 19 29 30 35 36 38 39 42 45
R ENTETE
1 20 'Liste des primes'
MATR 5 2 12
85 NOM 25 2 +1
2 70 DATE EDTCDE(Y)
4 1 'Date Montant'
R LIGNE
DATEP 8 1 EDTCDE(Y)
N01
O 02 04 06 MONT 9 12
HSUP 1 25 HIGHLIGHT
R TOTAL
2 'TOTAL :'
MONTT 10 11
Dans cet exemple, il n'y a pas de SDD au niveau fichier, cette SDD n'est
nécessaire que dans certains cas.
Les SDD doivent être écrites en majuscules, sauf les libellés constants entre
quotes, qui peuvent contenir des minuscules, pour améliorer la présentation des
états.
Toutes les lignes de SDD doivent avoir un "A" en colonne 6.
Un étoile en colonne 7 (colonne A/O/*) transforme une ligne de SDD en ligne de

commentaire libre.
Les lignes de SDD du niveau format d'impression portent la lettre "R" en colonne
17. Il y en a 3 dans cet exemple.

Les autres lignes (sans "R") définissent les champs d'impression.
Passons maintenant en revue les différentes colonnes à remplir dans une SDD
d'impression.
5.2.1. Indicateurs de condition : colonnes 8 à 16

Vous pouvez utiliser les indicateurs de condition des colonnes 8 à 16 pour
conditionner l'impression ou la non-impression d'un champ. Si le ou les
indicateurs sont à '1' au moment de l'impression, le champ sera imprimé. Il ne sera
pas imprimé si l'un au moins des indicateurs vaut '0'. Cela peut être commode
pour vous éviter de programmer une remise à blanc du champ en question.
Mais il faudra tout de même, dans votre programme, positionner à '0' ou à '1' le ou
les indicateurs de condition concernés. Voir dans l'exemple ci-dessus : la variable
NOM qui est conditionnée par l'indicateur 85.
Vous pouvez inverser les indicateurs, en mettant la lettre "N" en colonne 8 ou 11

ou 14. Vous pouvez faire des conditions composées assez complexes, en mettant
un "A" ou un "O" en colonne 6, ce qui permet de lier par un AND ou un OR
plusieurs lignes d'indicateurs condition. La rubrique MONT conditionnée par la
combinaison "non-indicateur 01 ou indicateur 02 et indicateur 04 et indicateur 06"
en est un exemple.
5.2.2. Nom : colonnes 19 à 28

Vous y placerez le nom du format d'impression, s'il s'agit d'une ligne "R".
Dans l'exemple : ENTETE, LIGNE et TOTAL.
Dans le cas de lignes définissant des champs, vous ne spécifierez un nom que pour
les champs variables. Laissez la colonne nom à blanc pour les champs constants.
Les champs variables : MATR, NOM, DATEP, MONT, HSUP, MONTT
Les champs constants : 'Liste des primes'

DATE qui représente la date du jour
'Date Montant'
'Total :'

5.2.3. Longueur : colonnes 30 à 34
Spécifiez la longueur totale du champ sur votre état, y compris virgule et
décimales. Cela concerne uniquement les champs variables, ceux dont vous avez
déjà spécifié le nom.
La longueur doit être cadrée à droite dans les colonnes 30 à 34.
5.2.4. Type de données : colonne 35

On y met en principe:
"A" pour les zones en caractères (alphanumériques)

"S" pour les zones numériques
Mais vous allez voir ci-dessous que c'est facultatif.
5.2.5. Positions décimales : colonnes 36 et 37
Si le champ est de type "caractères", laisser à blanc. Alors le "A" en colonne 35

devient facultatif.
Si le champ est numérique, mettre le nombre de décimales, ou "0" si pas de

décimale. Dans ce cas le "S" en colonne 35 est facultatif !
5.2.6. Ligne et colonne : colonnes 39 à 44
Ces deux colonnes ne concernent que les SDD au niveau champ, qu'il soit
constant ou variable.
Vous pouvez y indiquer le numéro de ligne et de colonne où doit se placer le

champ que vous définissez.
Le numéro de ligne est compté à partir du haut de la page, il est facultatif.

Si vous ne l'indiquez pas, le champ s'imprimera à la ligne en cours.
Si vous l'indiquez, il s'imprimera à la ligne spécifiée.
Le numéro de colonne doit être compris entre 1 et 132, si vous utilisez du listing
large (380 mm), et entre 1 et 80 pour du papier au format classique A4 (210mm x
297mm).

Le numéro de colonne peut être un numéro relatif, s'il est précédé du signe "+".
Exemple : le champ NOM sera imprimé en laissant 1 espace (d'où le "+1") à

droite du champ constant MATR.
Ces numéros de ligne et de colonne doivent être cadrés à droite.
5.2.7. Les fonctions : colonnes 45 à 80
Les colonnes 45 à 80 peuvent être utilisées pour les SDD niveau fichier, niveau
format et niveau champ.
Cette zone fonctions peut contenir plusieurs fonctions si nécessaire. Dans ce cas,
les fonctions devront être séparées par au moins un blanc. Chaque fonction peut
avoir des paramètres qui devront être entre parenthèses.
Si une fonction nécessite plusieurs paramètres, ceux-ci devront être séparés par au
moins un blanc.
Si les colonnes 45 à 80 ne suffisent pas pour coder toutes les fonctions d'un
champ, vous pouvez utiliser des lignes-suite. Terminez la ligne de fonctions que
vous êtes en train d'écrire par un caractère "+". Continuez simplement sur la ligne
suivante la suite de vos fonctions entre les colonnes 45 et 80.
Voyons le détail des principales fonctions de SDD disponibles pour les fichiers
d'impression.
Il y en a 35 en tout, nous n'en verrons que quelques-unes. Les autres sont

abondamment expliquées dans le document de base IBM intitulé " DATA
DESCRIPTION SPECIFICATIONS - REFERENCE".
Nous les prendrons par ordre alphabétique.
5.2.8. Fonction BARCODE
Signalons seulement son existence. Vous trouverez ses paramètres dans la

documentation sur les SDD.
Elle se code au niveau champ.
Elle permet d'imprimer des données sous forme de leur code à barre. Elle n'est
disponible que sur les imprimantes de type IPDS.

5.2.9. Fonction CHRSIZ
Taille des caractères.

Se code au niveau format ou champ.
Par exemple :
CHRSIZ(3 4)
Dans cet exemple, 3 est la largeur du caractère et 4 sa hauteur.
Largeur et hauteur doivent être comprises entre 1 et 20.
Ne fonctionne que sur les imprimantes de type IPDS.
5.2.10. Fonction CPI
Spécifie le nombre de "Characters per Inch", c'est-à-dire le nombre de caractères

par pouce. Se code au niveau format ou champ. Deux valeurs possibles 10 ou 15.
Exemple :
CPI(10)
Cette fonction n'est disponible que sur les imprimantes matricielles de type IBM
5224 ou IBM 5225.
5.2.11. Fonction DATE

Cette fonction n'a pas de paramètres, et imprime la date système de l'ordinateur
sous la forme :
JJMMAA
Si vous voulez la forme suivante :
JJ/MM/AA
ajoutez une autre fonction (que nous verrons plus loin) , c'est la fonction
EDTCDE(Y), vous taperez donc en colonne 45 de vos SDD:

DATE EDTCDE(Y)
Vous trouverez un exemple dans le format ENTETE plus haut.
5.2.12. Fonction DFNCHR

Cette fonction permet de se définir ses propres dessins de caractères.
Utilisation rare, mais intéressante. Elle se code au niveau fichier ou au niveau
format. Voir les paramètres dans la documentation.
Ne fonctionne que sur IBM 5224 ou IBM 5225.
5.2.13. Fonction EDTCDE
Cette fonction est très utilisée. Elle permet d'afficher un champ en spécifiant un
certain format d'impression (on dit aussi "masque d'impression", ou "code
d'édition")
Elle nécessite un paramètre qui est un caractère à choisir dans la liste suivante :
chiffre de 1 à 4 : codes d'édition sans signe moins si la zone est négative.
chiffres de 5 à 9: codes d'édition particuliers que vous pouvez vous définir vous-
même.
Utilisez pour cela la commande CL : CRTEDTD.
lettres A à D: codes d'édition financiers.
lettres J à M: codes d'édition courants pour champs numériques :

J et K impriment les virgules
L et M n'impriment pas les virgules
K et M mettent un blanc si la zone est à zéro
J et L impriment le chiffre zéro si la zone est à zéro.
lettre Y: code d'édition réservé à l'impression de champs dates.

Ce code insère deux caractères "/".
5.2.14. Fonction EDTWRD

Cette fonction concerne elle aussi les formats d'édition de champs.

Elle est à utiliser si les quelques codes d'édition utilisés dans EDTCDE ne
suffisent pas, dans le cas où vous voulez obtenir un format d'édition très
particulier.
Voici donc encore une autre technique qui complète celle décrite ci-dessus (avec
les codes 5 à 9).
Voir la documentation IBM pour les paramètres de la fonction EDTWRD.
5.2.15. Fonction HIGHLIGHT
Pour imprimer en gras les champs désirés. Cette fonction se code au niveau format
ou au niveau champ. Elle ne fonctionne qu'avec des imprimantes de type IPDS ou
SCS.
Exemple avec le champ HSUP.
5.2.16. Fonction PAGNBR
Cette fonction imprime le numéro de page à l'endroit désiré. Il sera calculé

automatiquement par le système d'exploitation.
Utilisable au niveau champ seulement, cette fonction n'a pas de paramètres.

Exemple ci-dessous :
SDD donn. décim
R ENTETE
2 70 'Page numéro :'
2 85 PAGNBR
5.2.17. Fonction SKIPA

Cette fonction permet, lors de l'impression, de sauter à la ligne dont le numéro est
spécifié dans le paramètre.

Elle est utilisable aux 3 niveaux : fichier, format et champ. Elle nécessite un seul
paramètre.
Le saut a lieu juste après l'impression du fichier, du format ou du champ, car le

"A" de SKIPA signifie "skip after", c'est-à-dire "saute après".
Exemple de fonction SKIPA définie au niveau d'un champ :
SDD donn. décim
PRIX SKIPA(2)
Il y aura un saut à la ligne numéro 2 après l'impression du champ PRIX.
5.2.18. Fonction SKIPB
Comme SKIPA, mais le saut a lieu avant l'impression, et non après, car le "B" de
SKIPB signifie "skip before", c'est-à-dire "saute avant".
Exemple d'utilisation de SKIPB au niveau format :
SDD donn. décim
R ENTETE SKIPB(5)
Avant d'imprimer le format ENTETE et son contenu qui n'est pas détaillé ci-
dessus, l'imprimante sautera à la ligne numéro 5.
5.2.19. Fonction SPACEA

Dans le SKIPA, nous venons de voir que l'impression saute à la ligne spécifiée en
paramètre. Dans le SPACEA, l'impression saute autant de lignes que le nombre
spécifié en paramètre. Le saut a lieu après l'impression.
Exemple :
SDD donn. décim

R ENTETE
CHAMP1 3 1 SPACEA(2)
CHAMP2 5 1
Il y aura donc un saut de deux lignes entre les champs CHAMP1 et CHAMP2.
5.2.20. Fonction SPACEB

Comme SPACEA, mais le saut a lieu avant l'impression.
Exemple qui produira exactement le même résultat que l'exemple précédent :
SDD donn. décim
R ENTETE
CHAMP1 3 1
CHAMP2 5 1 SPACEB(2)
5.2.21. Fonction TIME

Cette fonction sans paramètre ne s'utilise qu'au niveau champ. Elle permet
l'impression de l'heure système. C'est l'homologue de la fonction DATE.
Exemple :
SDD donn. décim
R ENTETE
3 60 'Heure d'impression: '
3 75 TIME
5.2.22. Fonction UNDERLINE

Sans paramètre, cette fonction au niveau champ demande le soulignement du
champ concerné. Elle n'est disponible que sur certaines imprimantes.
Exemple :

SDD donn. décim
R ENTETE
3 60 'Heure d'impression : '
3 75 TIME UNDERLINE
L'heure est maintenant soulignée.

5.3. Mettre en oeuvre des SDD
5.3.1. Saisir des SDD
La saisie des SDD se fait à l'aide de l'éditeur de source SEU, le même qui sert à la
saisie des programmes GAP ou COBOL. La seule différence par rapport à la
saisie d'un programme est que vous allez saisir votre source SDD dans un fichier
source spécifique nommé QDDSSRC.
Rappelons que vous utilisiez jusqu'ici le fichier source QRPGSRC pour y saisir du
GAP, ou QCBLSRC pour y saisir du COBOL. Vous allez créer ce fichier
QDDSSRC qui n'existe vraisemblablement pas encore dans votre bibliothèque.
Tapez l'ordre CL suivant pour créer QDDSSRC dans votre bibliothèque :
CRTSRCPF FILE(QDDSSRC)
Puis appelez l'utilitaire SEU pour saisir vos SDD dans ce fichier. Cela va donner
lieu à un premier membre source dans QDDSSRC.
Pour appeler SEU, tapez :
STRSEU
ou encore, pour plus de convivialité :
STRPDM
5.3.2. Compiler des SDD
Il ne vous reste plus qu'à compiler les SDD que vous venez de saisir. Le résultat
de la compilation sera :
- un compte rendu de compilation sur papier, qui sera stocké dans un fichier
SPOOL
- un autre fichier SPOOL nommé QPJOBLOG, si le compilateur a trouvé des

erreurs dans vos SDD
- le fichier d'impression que vous vouliez créer, s'il n'y a pas eu d'erreur
d'impression.

Pour lancer la compilation, le plus simple est de taper l'option 14 dans PDM, en
face du nom du membre source à compiler. La compilation se lancera sous forme
d'un travail batch.
Sachez que l'option 14 de PDM déclenche une commande de compilation qui est
la commande :
CRTPRTF
avec tous ses paramètres.
Si votre fichier d'impression est bien créé, vous pouvez passer ensuite à la
compilation. Puis, exécutez votre programme d'impression GAP (ou COBOL) en
utilisant l'un des deux ordres CALL ou SBMJOB que nous avons déjà rencontrés.
Bonne chance !

6. Les SDD de fichiers de données
6.1. Les trois parties d'un fichier physique de

données
Sur AS/400 comme sur tout ordinateur un fichier de données est un ensemble
d'enregistrements.
Par exemple, le fichier du personnel contient une fiche par salarié.

Le terme informatique correspondant à fiche est "enregistrement".
L'équivalent du mot "enregistrement" dans la littérature anglo-saxonne est
"record".
Un enregistrement contient un certain nombre de rubriques, encore appelées

"zones" ou "champs" ou "fields" en anglais.
Par exemple, le fichier du personnel peut contenir les rubriques suivantes :
matricule, nom, prénom, emploi, service, adresse, téléphone, salaire, emploi
précédent, diplôme, etc.
Tous les enregistrements d'un même fichier ont la même structure. Toutefois, sur
AS/400, un fichier peut avoir plusieurs types d'enregistrements.
Par exemple, si notre fichier du personnel contient à la fois les employés
permanents de l'entreprise et les personnels temporaires, pour lesquels on stockera
beaucoup moins d'informations, on aura certainement intérêt à utiliser deux types
d'enregistrements.
On dira alors qu'on a deux "formats d'enregistrements" : le format concernant le

personnel permanent, et le format concernant le personnel temporaire.
Mais en pratique, les fichiers multiformat sont interdits sur AS/400, comme sur
toute base de données relationnelle, et à cause de la nature même de ces bases. Ils
seraient par ailleurs incompatibles avec des méthodes rigoureuses d'analyse
fonctionnelle.
Descendons maintenant au niveau de la rubrique.

Chaque rubrique porte un nom, par exemple le programmeur peut décider de
donner le nom "PECOD" pour identifier le code postal dans les enregistrements
du fichier du personnel.
Un petit conseil au passage : arrangez-vous pour "glisser" dans les noms de

rubriques le nom du fichier auquel elles appartiennent. Dans notre exemple, on
saura que tous les noms de rubriques commençant par "PE" appartiennent au
fichier du PErsonnel. Ceci évitera bien des confusions, et bien des "bugs"...

Chaque rubrique est d'un certain type et a une certaine longueur.
Si la rubrique est numérique, elle pourra avoir les 4 types suivants :
P = numérique décimal packé signé ou encore numérique condensé.

Chaque chiffre est codé sur un demi-octet.
Compter en plus le signe pour un demi-octet.
Comme la longueur est un nombre entier d'octets,
une rubrique numérique de 4 chiffres occupera 3 octets.
Quelle sera la longueur d'une rubrique de 7 chiffres ?
Cherchez quelques instants. Bip, bip, bip.
Encore quelques secondes.
Bravo, vous avez trouvé, la réponse est 4.
S = numérique décimal signé ou encore numérique étendu.

Chaque chiffre est codé sur un octet.
B = numérique binaire.
Chaque octet contiendra 8 chiffres binaires.
F = flottant.
C'est la notation mathématique, avec les puissances de 10.
Par exemple : 1,649356 x 1034
Si la rubrique est alphanumérique, elle aura forcément le type suivant :
A = alphanumérique.
Peut contenir n'importe quel caractère.
Chaque octet contient 1 caractère.
Nous allons maintenant expliquer la structure d'un fichier physique de données. Le

mot "physique" ne doit pas vous affoler, sachez simplement que nous verrons
dans un autre chapitre l'autre catégorie de fichiers qu'est celle des fichiers
"logiques".
Nous venons de décomposer un fichier de données en enregistrements, puis en

rubriques.
Mais, attention, nous ne nous sommes intéressés qu'à une partie du fichier : la
partie contenant les données.
En effet, sur AS/400, un fichier physique de données contient les trois parties
suivantes :

- la description de la structure de l'enregistrement type, c'est-à-dire la
liste des noms de rubriques, sans le contenu des rubriques, bien sûr.
Juste le nom, le type et la longueur de chaque rubrique.
Si le fichier contient plusieurs formats, il y aura autant de descriptions de
structures d'enregistrements que de formats d'enregistrements.
- le chemin d'accès. Il s'agit de l'ordre dans lequel le fichier sera lu, si on le

lit séquentiellement du début à la fin.
Je vais vous donner plus d'explications un peu plus loin.
- les données proprement dites du fichier, qui sont appelées "data" en anglais.
C'est l'ensemble des enregistrements.
Revenons à la deuxième partie du fichier qu'est le chemin d'accès.

Distinguons deux cas.
Ou bien le fichier n'est pas indexé, et alors le chemin d'accès ne permettra

d'accéder aux enregistrements que dans l'ordre dans lequel ils ont été créés.
L'accès direct à l'enregistrement numéro N ne sera pas possible, puisqu'il faudrait
d'abord lire les N-1 enregistrements précédents.
Ou bien le fichier est indexé, ce sera le cas général, et le chemin d'accès permettra
d'accéder au fichier dans l'ordre des clés d'index, et non plus dans l'odre de
création des enregistrements.
Et en plus de cet accès séquentiel, on aura la possibilité de faire des lectures par
accès direct.
En effet le chemin d'accès du fichier est organisé en table d'index, comme un
index d'une encyclopédie, afin de pouvoir accéder directement à un enregistrement
sans lire tous ceux qui précèdent.
Le principe en est simple.

Le système d'exploitation numérote automatiquement de 1 à N tous les
enregistrements d'un fichier, dans l'ordre de leur création.
Chaque enregistrement est donc ainsi numéroté. La table d'index du fichier du
personnel, si celui-ci est indexé sur le nom des salariés, par exemple, contient la
liste de tous les noms du fichier en ordre alphabétique, avec en regard de chaque
nom, le numéro d'enregistrement correspondant.
Supposons que, dans un de vos programmes, vous mettiez un ordre de lecture

directe d'un enregistrement, connaissant le nom du salarié.
Le système d'exploitation va chercher dans la table d'index le nom recherché, il
obtiendra ainsi le numéro de l'enregistrement. Ensuite, connaissant le numéro
d'enregistrement, il ira lire directement cet enregistrement.
Un fichier indexé aura ou bien une clé simple ou bien une clé composée. Une clé
composée est constituée de plusieurs rubriques, alors qu'une clé simple n'est
composée que d'une seule rubrique.

Par exemple, on peut définir un chemin d'accès grâce à la clé "matricule", c'est
une clé simple.
Ou bien alors, on peut définir un autre chemin d'accès grâce à la clé composée
"service" et "nom".
Le chemin d'accès ainsi défini permettra de lire les enregistrements dans l'ordre
des services et, à l'intérieur de chaque service, dans l'ordre alphabétique des noms.
Dans cette clé composée, la clé "service" est appelée clé majeure, alors que la clé
"nom" est appelée clé mineure.
Le schéma de la page suivante illustre bien les trois parties qui composent un
fichier physique de données. Vous y verrez aussi le principe de la table d'index qui
constitue le chemin d'accès.

6.2. Pour créer un nouveau fichier physique...
Un fichier physique se définit par des SDD, tout comme un fichier d'impression.
La création d'un fichier physique passera nécessairement par les 4 phases

suivantes :
- la conception des SDD sur papier;
- la saisie des SDD à l'aide de SEU;
- la compilation des SDD;
- le remplissage du fichier par des données.
6.2.1. La conception et la saisie des SDD
Ces deux premières phases sont semblables à celles qui sont nécessaires à la
création d'un fichier d'impression.
Revoir le chapitre sur les SDD d'impression si ce n'est plus tout à fait clair.
Vous vous demandez peut-être comment vous remplirez les imprimés de SDD,
nous allons le voir très prochainement.
6.2.2. La compilation des SDD
Cette troisième phase est elle aussi semblable aux fichiers d'impression.
La phase de compilation des SDD aboutira à :
- l'impression d'un compte rendu de compilation signalant les éventuelles erreurs

que vous auriez commises dans les SDD;
- l'impression d'un rapport appelé QPJOBLOG, uniquement en cas d'erreurs de

compilation;
- la création du fichier physique proprement dit.

Le fichier physique comprendra dès sa création les trois parties mentionnées ci-
dessus : format, chemin d'accès et données.
Cependant la partie données sera vide au départ, ainsi que la partie chemin
d'accès.
Attention
Supposons que vous vouliez modifier le format d'enregistrement d'un fichier déjà
existant contenant des données, pour rallonger un libellé, par exemple.
Ce qui est écrit ci-dessus reste malheureusement vrai.
C'est-à-dire que la partie donnée de votre fichier sera vide après compilation!
En clair, vous aurez perdu toutes vos données.
Si vous tenez à votre emploi, évitez cet exploit !
Préférez la solution suivante.

Sauvegardez d'abord vos données dans un autre fichier, puis modifiez vos SDD,
recompilez votre fichier, et recopiez les données seules (mais surtout pas le fichier
complet) du fichier de sauvegarde vers le nouveau fichier ayant le nouveau
format.
Pour compiler les SDD, vous procéderez comme pour les fichiers d'impression, en
tapant le numéro d'option 14 en face du nom du membre source contenant les
SDD. La compilation sera ainsi lancée en batch.
Sachez toutefois que l'option 14 déclenche la commande CL suivante avec ses

paramètres:
CRTPF
Ce qui signifie : "create physical file".

Rappelons que l'ordre équivalent pour les fichiers d'impression était CRTPRTF:
"create printer file".
6.2.3. Le remplissage du fichier physique
Remplir le fichier physique à l'aide de données peut se faire de deux façons :
- en utilisant un programme GAP OU COBOL qui contiendrait des ordres

d'écriture dans le fichier;
- en utilisant le programme utilitaire IBM nommé DFU (ou UCMF en français).

6.3. Les SDD des fichiers physiques
On retrouve, comme dans les fichiers d'impression, les trois niveaux de

spécifications:
- niveau du fichier;
- niveau du format d'enregistrement;
- niveau des rubriques.
Vous trouverez ci-dessous un exemple simple de SDD concernant un fichier du

personnel:
Type Nom Réfé. Longueur Type Posit. Fonctions

SDD donn. décim
UNIQUE
R PEENREG
PEMAT 4 A COLHDG('Matricule')
PENOM 20 A
PESAL 8 2 RANGE(5000 15000)
PESER 2 A
K PEMAT
Le nom du format d'enregistrement est PEENREG.

Il ne peut pas y avoir plusieurs formats d'enregistrements dans un fichier
physique.
Les rubriques se nomment PEMAT pour le matricule du salarié, PENOM pour

son nom, PESAL pour son salaire, et PESER pour le code du service dans lequel
il travaille.
Le chemin d'accès est indexé sur la clé PEMAT.
Trois fonctions ont été utilisées dans cet exemple.

La fonction COLHDG, qui signifie "column heading" = en-tête de colonne,
permettra d'imprimer ou d'afficher le libellé "Matricule" dans tous les programmes
utilitaires IBM, en haut de la colonne PEMAT.
La fonction RANGE permet de spécifier une fourchette de valeurs possible pour

la rubrique concernée. Le contrôle se fera dans tous les programmes de saisie de
cette zone.

La fonction UNIQUE indique que l'on interdit d'avoir un matricule en double dans
le fichier. Elle est codée avant le format d'enregistrement, elle est donc relative au
fichier dans sa globalité.
Cette fonction est indispensable pour un critère d'identification unique.
Mais ces trois fonctions n'étaient là qu'à titre d'exemple, simplement pour vous
mettre en appétit.
Voici la liste complète de toutes les fonctions disponibles dans les SDD de
fichiers physiques.
Nous en détaillerons quelques-unes plus loin.
ABSVAL
ALIAS
ALTSEQ
CHECK
CMP
COLHDG
COMP
DESCEND
DFT
DIGIT
EDTCDE
EDTWRD
FIFO
FLTPCN
FORMAT
LIFO
NOALTSEQ
RANGE
REF
REFFLD
REFSHIFT
SIGNED
TEXT
UNIQUE
UNSIGNED
VALUES
ZONE

6.3.1. Fonction COLHDG
Comme indiqué ci-dessus, cette fonction déclare des en-têtes de haut de page
systématiques sur les états ou écrans générés par les utilitaires IBM, mais pas les
états et écrans générés par vos propres programmes.
Pour spécifier un en-tête sur plusieurs lignes, faire comme suit :
COLHDG('Référence' 'article')
Alors que la spécification suivante imprime l'en-tête sur une seule ligne :
COLHDG('Référence article')
6.3.2. Fonction COMP
Cette fonction est totalement identique à la fonction CMP.

Elle sert à tester la validité de la zone concernée au moment de la saisie de cette
zone.
Vous pourrez l'utiliser dans vos programmes interactifs. Ainsi, vous n'aurez pas
besoin de mettre ce contrôle dans votre programme, ce qui l'allégera d'autant.
La syntaxe de la fonction COMP est la suivante :
COMP(opérateur valeur)
Par exemple, pour demander à ce que la zone concernée soit inférieure à 15000 :
COMP(LT 15000)
Autre exemple : pour demander à ce que la rubrique concernée soit égale à

FRANCE :
COMP(EQ 'FRANCE')

Vous avez droit aux opérateurs maintenant classiques :
EQ equal
NE not equal
LT less than
NL not less than
GT greater than
NG not greater than
LE less than or equal
GE greater than or equal
La valeur de comparaison doit être comme d'habitude :
- entre simples quotes si la rubrique est alphanumérique;

- sans quote si la rubrique est numérique.
6.3.3. Fonction DESCEND
Cette fonction n'est utilisable que dans les lignes de spécifications de clé portant
un K en colonne 17.
Elle demande que le chemin d'accès soit constitué dans l'ordre décroissant de la
clé.
Vous avez ci-dessous un exemple de clé composée.
Le fichier sera classé par ordre de code service croissant, puis à l'intérieur de
chaque service, le classement sera par salaire décroissant.

SDD donn. décim
K PESER
K PESAL DESCEND
Nous aurons donc le fichier dans l'ordre suivant :
129 MULLER 8872,60 AA

256 PIERRE 6785,89 AA
025 DUPONT 9873,78 CD
161 DURAND 8976,23 CD
009 DUVAL 2974,36 CD
278 MARTIN 9945,90 DA
013 ROSSIGNOL 5612,89 DA
567 DUBOIS 5600,67 DA

6.3.4. Fonctions EDTCDE et EDTWRD
Comme pour les fichiers d'impression, ces fonctions définissent le mode

d'impression ou d'affichage de la rubrique concernée. Les mêmes codes sont
disponibles.
Se référer à la documentation sur les fichiers d'impression.
Si vous ne spécifiez rien pour ce nom de rubrique dans votre fichier d'impression
(ou en interactif dans votre fichier écran), c'est la fonction définie au niveau du
fichier de données qui sera prise en compte.
6.3.5. Fonctions FIFO et LIFO
Dans le cas où vous ne demandez pas de clé unique (pas de fonction UNIQUE en
ligne K), vous risquez d'avoir des enregistrements en double ou en triple pour une
même clé.
La question se pose alors de savoir dans quel ordre vous souhaitez les lire.
Deux possibilités :
- l'ordre de classement FIFO, c'est-à-dire First In First Out (premier entré, premier
sorti). Les enregistrements seront donc lus dans l'ordre de leur création.
- l'ordre de classement LIFO, c'est-à-dire Last In First Out (dernier entré, premier
sorti). Les enregistrements seront lus dans l'ordre inverse de leur création.
6.3.6. Fonction RANGE
Comme nous l'avons vu dans l'exemple, cette fonction permet de définir une
fourchette de valeurs admissibles.
Le contrôle se fera uniquement au moment de la saisie de la rubrique concernée.
Si le champ est alphanumérique, ne pas oublier de mettre les valeurs entre simples
quotes.

6.3.7. Fonction TEXT
Permet seulement d'ajouter un commentaire qui permettra de relire plus facilement

vos SDD.
Exemple :

SDD donn. décim
PESER 2 A TEXT('Code du service')
6.3.8. Fonction UNIQUE
Déjà expliquée dans l'exemple au début de cette liste des fonctions.
6.3.9. Fonction VALUES
Tout comme les fonctions RANGE et COMP, cette fonction vous permet de
décharger de certains contrôles votre programme de saisie.
La fonction VALUES va vérifier que la valeur saisie est bien dans la liste fournie.
Exemple sur les valeurs possibles du code "situation maritale" :

SDD donn. décim
SITMAR 1 A VALUES('C' 'M' 'V' 'D')

6.4. Les deux parties d'un fichier logique
Venons-en maintenant aux fichiers logiques.
Un fichier logique n'a pas 3 parties comme un fichier physique mais 2 seulement.
La partie manquante est la partie "données". Un fichier logique n'a pas de données
en propre. Il "puise" ses données, non pas en lui-même comme un fichier
physique, mais dans un autre fichier physique, auquel il est lié.
Quel est l'intérêt d'avoir ainsi deux fichiers basés sur les mêmes données ?
D'abord, le format du fichier logique peut être différent de celui du fichier

physique. Si vous n'êtes intéressé que par 3 rubriques de votre fichier physique qui
en compte 20, vous pouvez définir le format d'enregistrement de votre fichier
logique avec seulement ces trois rubriques.
Ensuite le chemin d'accès du fichier logique peut être différent de celui du

fichier physique, et c'est essentiellement là qu'est l'avantage.
Un fichier logique aura son propre chemin d'accès, c'est-à-dire son propre ordre de
classement des enregistrements, qui sera en général différent de l'ordre de
classement du fichier physique.
Encore plus fort, le chemin d'accès pourra ne prendre en compte que certains
enregistrements. Un fichier logique pourra donc être une sélection de certains
enregistrements d'un fichier physique, et cela éventuellement dans un autre ordre
de classement.
Un exemple.
Le fichier des articles d'une entreprise contient deux catégories d'articles : les
articles gérés en stock, et les autres gérés par commande. Le commercial a besoin
du fichier de tous les articles du fichier classés par ordre de référence article. Il
utilisera donc le fichier physique avec un classement par référence.
Le magasinier a besoin d'une simple liste des articles gérés en stock, classée par
ordre alphabétique de désignation. Il utilisera un fichier logique qui "s'appuie"
(c'est le terme dans le jargon AS/400) sur le fichier physique général des articles.
Ce fichier logique aura un chemin d'accès qui ne sélectionne que les articles en
stock, et qui les classe par désignation.
Observez bien l'exemple ci-dessous sur le fichier du personnel.

Le fichier logique sélectionne les salariés dont le matricule est supérieur à "100",
et les classe par code service.

6.5. Les SDD des fichiers logiques
Un fichier logique se crée de la même façon qu'un fichier physique : avec des
SDD, qui, une fois compilées, donneront lieu à un nouvel objet : le fichier
logique.
Cependant, avant de créer un fichier logique, il faudra préalablement que le fichier

physique associé existe, c'est évident.
Les phases de création d'un fichier logique sont donc les suivantes :
- rédaction des SDD sur papier;
- saisie des SDD à l'aide de SEU;
- compilation des SDD.
La phase de saisie des données est bien sûr inutile puisque les données existent
déjà dans le fichier physique.
La compilation des SDD se fait toujours avec l'option 14 dans PDM, et génère
automatiquement une commande CL de création de fichier logique, c'est la
commande:
CRTLF
qui signifie "create logical file".
Nous allons voir que de nouvelles fonctions vont être disponibles dans les SDD
des fichiers logiques.
Voyons par exemple les SDD d'un fichier logique associé au fichier physique du
personnel :

SDD donn. décim
R PEENREG2 PFILE(PERS)
PENOM 7
PEMAT
PESER
K PESER
S PEMAT COMP(GT '100')

Plusieurs différences par rapport aux SDD d'un fichier physique.
La différence la plus importante: la présence du paramètre PFILE. Ce paramètre,

qui signifie "physical file", permet d'indiquer le nom du fichier physique associé
au fichier logique. Il assure donc le lien entre le fichier logique et le fichier
physique.
Autre petite différence, la longueur des rubriques PEMAT et PESER n'est pas
spécifiée. C'est tout simplement parce que l'on reprend la même longueur que dans
le fichier physique pour ces deux zones.
En revanche, le programmeur a décidé de raccourcir la rubrique PENOM dont la
longueur était de 9 dans le fichier physique.
Encore un élément nouveau, la dernière ligne, qui contient un S en colonne "type

de SDD".
Ce nouveau type de SDD va servir à "S"électionner certains enregistrements, ici,
on ne conservera que ceux dont le matricule est strictement supérieur à 100.
La fonction COMP est utilisée ici pour préciser la condition de sélection, mais il
aurait été possible d'utiliser les autres fonctions RANGE ou VALUES, que nous
avons vues au niveau des rubriques de fichiers physiques.
On pourra trouver des cas où plusieurs lignes S seront nécessaires, par exemple, si
l'on veut sélectionner les matricules compris entre 100 et 300, on écrira :

SDD donn. décim
PENOM 7
PEMAT
PESER
K PESER
S PEMAT COMP(GT '100')
S PEMAT COMP(LT '300')
Dans le même ordre d'idées, il existe un autre type de SDD.

C'est le type O, comme "Omit", c'est-à-dire: omettre. C'est en fait exactement
l'inverse du type S.
On n'indiquera plus la condition de sélection, mais la condition d'omission.

Voici la façon de demander les matricules compris entre 100 et 300 en utilisant le
type de ligne O :

SDD donn. décim
PENOM 7
PEMAT
PESER
K PESER
O PEMAT COMP(LE '100')
O PEMAT COMP(GE '300')
Pour de plus amples renseignements sur les conditions, en particulier les

conditions composées avec des OU et des ET, voir la Bible IBM, en l'occurrence
le livre "Data Description Spécifications - Reference".
Voilà pour les cas les plus courants de fichiers logiques.
Mais nous allons reprendre la liste de toutes les fonctions possibles utilisables
dans les fichiers logiques.
Puis, comme nous l'avons fait pour les fichiers physiques, nous reprendrons en
détail les fonctions les plus usitées.

Voici donc la liste complète de toutes les fonctions :
ABSVAL
ALIAS
ALL
ALTSEQ
CHECK
CMP
COLHDG
COMP
CONCAT
DESCEND
DIGIT
DYNSLT
EDTCDE
EDTWRD
FIFO
FLTPCN
FORMAT
JDFTVAL
JDUPSEQ
JFILE
JFLD
JOIN
JREF
LIFO
NOALTSEQ
PFILE
RANGE
REFACCPTH
REFSHIFT
RENAME
SIGNED
SST
TEXT
TRNTBL
UNIQUE
UNSIGNED
VALUES
ZONE
Les fonctions en italique sont nouvelles par rapport aux fichiers physiques.

Notez aussi que certaines fonctions des fichiers physiques ont disparu.
Reprenons donc maintenant les fonctions nouvelles les plus usitées.
6.5.1. Fonction CONCAT
Cette fonction sert à "concaténer" plusieurs rubriques, c'est-à-dire mettre bout à

bout plusieurs rubriques du fichier physique, pour n'en faire qu'une seule dans le
fichier logique.
Par exemple, si un fichier physique contient les trois rubriques JOUR, MOIS et
ANNEE, on peut les concaténer dans un fichier logique en écrivant les SDD
suivantes :

SDD donn. décim
R ENREG1 PFILE(FICHIER1)
DATE CONCAT(JOUR MOIS ANNEE)
6.5.2. Fonction PFILE
Comme nous l'avons vu ci-dessus, c'est la fonction indispensable de tout fichier

logique.
Elle fait référence au fichier physique sur lequel "s'appuie" le fichier logique.
6.5.3. Fonction REFACCPTH
Cette fonction ne peut être spécifiée qu'au niveau fichier.
Avec cette fonction, le fichier logique n'aura pas son chemin d'accès propre,
comme nous l'avons expliqué plus haut, mais il partagera le chemin d'accès du
fichier spécifié en paramètre.
Cela peut permettre dans certains cas particuliers d'économiser de la place (un
chemin d'accès en moins à stocker sur disque), et aussi du temps (un chemin
d'accès en moins à mettre à jour).
Exemple :

SDD donn. décim
REFACCPTH(PERS)
PENOM
PEMAT
6.5.4. Fonction SST
Cette fonction est un peu l'inverse de la fonction CONCAT.

Elle permet d'extraire une sous-chaîne de caractères dans une chaîne de caractères.
Par exemple, pour trouver dans le numéro d'INSEE du fichier physique, le numéro
de département de naissance, il faudra extraire les deuxième et troisième
caractères.
Ce qui donne :

SDD donn. décim
R ENREG6 PFILE(SALARIE)
NOM
MAT
ANNEE I SST(INSEE 2 2)
K ANNEE DESCEND
Le fichier physique SALARIE contient la rubrique INSEE à 13 chiffres.
On indique dans la fonction SST le nom de la rubrique INSEE, suivi du numéro

du premier caractère que l'on veut extraire, et enfin le nombre de caractères que
l'on veut extraire. Remarquez que le type de donnée est "I", c'est-à-dire en entrée
seule.
Dans cet exemple, on a en plus indexé le fichier logique sur l'année en décroissant.

6.6. Des fichiers logiques particuliers
6.6.1. Les fichiers logiques multiformat
Un fichier physique ne peut avoir qu'un seul format d'enregistrement.

En revanche, un fichier logique peut avoir plusieurs formats d'enregistrement.
Nous n'irons pas très loin dans l'étude des fichiers logiques multiformat car ils ne
sont pas couramment utilisés, et ne sont pas très compatibles avec une analyse
fonctionnelle correcte et rigoureuse.
Prenons l'exemple des commandes client.
Pour chaque commande, nous avons des informations générales au niveau de l'en-
tête de la commande :
- le numéro de commande;
- le numéro de client.
Puis, nous avons les lignes de commande, avec dans chaque ligne :
- le code de l'article commandé;

- la quantité commandée.
On pourra donc faire deux fichiers physiques ayant des formats d'enregistrement
différents :
- le fichier des en-têtes de commande ENTETE;

- le fichier des lignes de commande LIGNE.

Sur la base de ces deux fichiers, on aura un fichier logique multiformat. Ce fichier
que nous pourrons appeler COMM regroupera les deux fichiers ENTETE et
LIGNE.
Donnons un exemple du contenu de ces fichiers :
FICHIER PHYSIQUE ENTETE
Numéro de commande Numéro de client
CO1 CL1
CO2 CL2
CO3 CL1
FICHIER PHYSIQUE LIGNE
Numéro de commande Code article Quantité

commandée
CO1 A1 80
CO1 A2 150
CO1 A5 100
CO2 A2 50
CO2 A5 160
CO3 A1 80
CO3 A6 200
FICHIER LOGIQUE COMM
Num de comm. Num de client Code article Quantité

comm.
CO1 CL1
CO1 A1 80
CO1 A2 150
CO1 A5 100
CO2 CL2
CO2 A2 50
CO2 A5 160
CO3 CL1
CO3 A1 80
CO3 A6 200

Il est clair ci-dessus que nous avons bien deux formats différents
d'enregistrements :
- les enregistrements contenant les rubriques : numéro de commande et numéro de

client;
- les enregistrements contenant les rubriques : numéro de commande, code article

et quantité commandée.
Le nombre d'enregistrements du fichier logique multiformat est égal à la somme

des nombres d'enregistrements des fichiers physiques concernés (7 + 3 = 10).
Voici les SDD nécessaires :
FICHIER PHYSIQUE ENTETE

SDD donn. décim
R ENRENT
ECOM 3
ECLI 3
K ECOM
FICHIER PHYSIQUE LIGNE

SDD donn. décim
R ENRLIG
LCOM 3
LART 3
LQTE 5 2
K LCOM
K LART
FICHIER LOGIQUE COMM

SDD donn. décim

R ENRENT PFILE(ENTETE)
ECOM
ECLI
K ECOM
R ENRLIG PFILE(LIGNE)
LCOM
LART
LQTE
K LCOM
K LART
6.6.2. Les fichiers logiques joints

Il s'agit ici d'une technique beaucoup plus intéressante que celle des fichiers
multiformat. C'est entre autres grâce aux fichiers logiques joints que la base de
données de l'AS/400 peut être qualifiée de "relationnelle".
Un fichier logique joint s'appuie sur plusieurs fichiers physiques, comme un

fichier logique multiformat. Mais dans le cas des fichiers joints, nous n'aurons
qu'un seul format d'enregistrement, dont les rubriques proviendront des fichiers
physiques.
Reprenons notre exemple des commandes clients. On pourra définir un fichier

joint qui aura l'apparence suivante :
FICHIER LOGIQUE JOINT COMM2
Numéro de commande Numéro d'article Quantité comm.

Client
CO1 A1 80 CL1
CO1 A2 150 CL1
CO1 A5 100 CL1
CO2 A2 50 CL2
CO2 A5 160 CL2
CO3 A1 80 CL1
CO3 A6 200 CL1
Ce fichier joint n'a que 7 enregistrements au lieu de 10 dans l'exemple précédent

de fichier logique multiformat. On pourra ainsi éviter de programmer un accès
direct pour rechercher la référence du client dans le fichier ENTETE.
La référence client est en effet immédiatement disponible, comme si elle existait
réellement dans l'enregistrement.

Les SDD des deux fichiers physiques restent inchangées.
Les SDD du fichier logique joint seront les suivantes :
FICHIER LOGIQUE JOINT COMM2

SDD donn. décim
R JFILE(LIGNE ENTETE)
J JOIN(LIGNE ENTETE)
JFLD(LCOM ECOM)
LCOM
LART
LQTE
ECLI
K LCOM
K LART
Les deux premiers paramètres JFILE et JOIN citent les fichier dont il faut faire la
jointure, et le paramètre JFLD indique les noms des champs qui doivent être en
correspondance pour que des enregistrements soient joints.
Ici, c'est le numéro de commande qui est commun aux deux fichiers.
Le premier fichier cité (LIGNE) est toujours le fichier primaire de la jointure.

Le ou les autres fichiers (un seul ici) sont des fichiers secondaires.
Le choix du fichier primaire est important, car le fichier logique joint aura autant
d'enregistrements que le fichier primaire.

7. Les SDD de fichiers écran
7.1. Présentation générale
Nous passons maintenant à la création de programmes interactifs. Ce n'est pas la

partie la moins intéressante de la programmation. De plus, sur 100 programmes,
on admet couramment que 20 sont des programmes batch, et 80 sont interactifs.
Pour ce type de programmes, il existe une méthode de programmation, appelée

méthode FAULLE, du nom de son inventeur : M. FAULLE. Cette méthode utilise
les principes de programmation structurée. Elle est de type "événementielle",
c'est-à-dire qu'à chaque événement tel que la frappe d'une touche de fonction va
correspondre une portion de programme, que l'on appelle "action".
Vous trouverez en annexe 6 un exemple commenté de programme interactif GAP
utilisant cette méthode.
Mais, pour l'instant, nous allons nous contenter d'apprendre à créer un fichier
écran. Un programme interactif utilise presque toujours un et un seul fichier écran.
Mais chaque fichier écran a, en général, plusieurs formats d'écran, chaque format
correspondant à une image écran. On retrouve donc sensiblement le même
principe que dans les fichiers d'impression, qui sont, rappelons-le, eux aussi
multiformat.
Chaque fichier écran doit être préalablement défini à l'aide de SDD qui devront
être comme d'habitude :
- rédigées sur papier à partir de vos maquettes d'écrans;
- saisies à l'aide de SEU dans un membre source;
- compilées à l'aide de l'ordre CL : CRTDSPF ou plus rapidement à l'aide de

l'option 14 dans PDM.
Cependant, nous verrons plus tard l'utilitaire IBM nommé SDA qui vous
permettra de générer automatiquement les SDD de vos fichiers écran. Cela vous
économisera les deux premières phases de rédaction et de saisie des SDD.
Mais il est préférable, dans la période d'apprentissage de l'AS/400 dans laquelle

vous êtes, de voir déjà dans le détail les SDD à rédiger. Puis seulement lorsque
vous aurez bien assimilé ces SDD, vous pourrez tirer pleinement profit des
automatismes de SDA.

Entrons dans le vif du sujet en voyant un exemple de SDD pour un fichier écran
contenant deux formats.
7.2. Constantes et variables
Ind 1 Ind 2 Ind 3 Type Nom Réfé Long Type Posit. Usage Ligne Col. Fonctions
SDD donn. décim
R ECRAN1
1 25 'INTERROGATION DU +
PERSONNEL'
10 5 'Tapez le matricule :'
E1MAT 4 B 10 30
R ECRAN2
1 25 'INTERRO DU PERSONNEL'
8 10 'Matricule:'
10 10 'Nom:'
12 10 'Salaire:'
E2MAT 4 O 8 20
E2NOM 20 O 10 20
E2SAL 10 Y 2 O 12 20
Ce fichier écran contient les deux formats d'écran nommés ECRAN1 et ECRAN2.
Les deux premiers champs de l'ECRAN1 sont de simples constantes à afficher.

Notez que la première constante a été décomposée sur deux lignes, avec le
caractère "+" de renvoi à la ligne suivante.
Pour programmer l'affichage d'un champ constant, il suffit, outre la constante elle-
même, d'indiquer les numéros de ligne et de colonnes où commence ce champ.
Le numéro de colonne doit être compris entre 1 et 80 et le numéro de ligne entre 1
et 24.
Après les champs constants, nous allons maintenant rencontrer des champs
variables. On distingue plusieurs usages pour ces champs, le code de l'usage est à
indiquer en colonne 38 des SDD.
Les champs variables en entrée servent à la saisie de donnée par l'utilisateur.

Pour tout champ en entrée, vous spécifierez le code usage "I" comme "input",
c'est-à-dire "entrée".

Les champs variables en sortie ne peuvent servir qu'à l'affichage de données par le
programme, la saisie de données par l'utilisateur y est impossible. Leur usage est
"O" comme "output", c'est-à-dire "sortie".
Certains champs variables peuvent être utilisés à la fois en entrée et en sortie.

Leur code usage sera "B" comme "both" ou en français : "les deux à la fois".
Dans le cas d'un champ caché, qui sera envoyé au terminal, mais restera invisible
sur l'écran, l'usage sera "H" comme "hidden" = "caché".
Champ E1MAT
Le champ E1MAT recevra le matricule tapé par l'opérateur.
Nous avons choisi de faire commencer le nom des champs par le nom du format
d'écran, c'est-à-dire que "E1" et "E2" cas se retrouvent dans les noms "E1MAT",
"E2MAT", "E2NOM", "E2SAL". Ce n'est pas obligatoire mais c'est très utile vous
y retrouver plus facilement dans vos programmes.
E1MAT est une donnée de type alphanumérique. On aurait pu mettre un "A" dans
la colonne type de données, mais comme alphanumérique est la valeur par défaut,
il n'est pas nécessaire d'écrire ce "A".
L'usage de ce champ est à la fois en entrée et en sortie : en entrée car c'est un

champ à saisir par l'utilisateur du programme, et en sortie car, si l'utilisateur tape
un matricule erroné, le programme devra envoyer ce champ à l'écran pour le
réafficher.
Il faut donc mettre un code usage "B".
Champs E2MAT, E2NOM, E2SAL
Dans l'écran ECRAN2, on trouve, hormis les constantes, trois champs en sortie,
dont l'usage est "O".
Pour le champ E2SAL, qui a la particularité d'être numérique, on mettra la lettre Y
dans la colonne "type de donnée", ce qui signifie : numérique.
Remarque : dans la colonne longueur, vous devez spécifier la longueur de la

donnée en mémoire et non sa longueur d'affichage à l'écran. Ces deux longueurs
peuvent différer dans le cas où l'on veut afficher la virgule décimale ou le signe
plus ou moins. Nous verrons plus loin, dans les codes d'édition, comment ajouter
ces caractères.

Autre remarque : tout champ est précédé d'un caractère spécial qui n'est pas
affiché, il sert à la gestion du champ par le système d'exploitation. C'est ce que
l'on appelle l'attribut du champ.
En conséquence, il ne sera pas possible d'accoler deux champs, sans laisser au
moins un espace eux pour l'attribut du deuxième de ces champs.
C'est pour la même raison qu'on ne pourra rien afficher dans le caractère 1 de la
ligne 1, puisque tout champ doit être précédé de son attribut.

7.3. Les touches de fonction
SDD donn. décim
CA01( 01 )
R ECRAN1 CA03( 03 )
E1MAT 4 B 10 30
R ECRAN2 CF07( 07 )
CF24( 24 )
8 10 'Matricule:'
10 10 'Nom:'
12 10 'Salaire:'
E2MAT 4 O 8 20
E2NOM 20 O 10 20
E2SAL 10 Y 2 O 12 20
Ici, nous avons simplement ajouté la possibilité d'utiliser des touches de fonction.
Rappelons que tout terminal d'AS/400 dispose des touches de fonction suivantes :
- les touches F1 à F24;

- la touche AIDE;
- la touche ENTREE;
- la touche PRINT;
- la touche HOME;
- la touche CLEAR;
- la touche ROLLUP (page écran suivante);
- la touche ROLLDOWN (page écran précédente).
Dans l'écran ECRAN1, nous avons rendu la touche fonction F3 utilisable.

Si la fonction CA03 n'est pas indiquée comme ici dans les SDD, l'appui sur F3
déclenche un message d'erreur signalant que cette touche n'est pas disponible.
Nous avons décidé d'associer la touche fonction F3 à l'indicateur 03, ce qui n'est
pas obligatoire mais cela paraît logique !
Ainsi, lorsque l'utilisateur appuiera sur la touche F3, l'indicateur 03 du programme
sera automatiquement positionné à 1. Il restera bien sûr à zéro dans tous les autres
cas.
Vous pourrez ainsi détecter aisément la touche sur laquelle l'utilisateur a appuyé.

Les fonctions CA01 à CA24 sont utilisables. Mais il n'y a pas de possibilité de
détecter l'appui sur la touche ENTREE. Dans la pratique, on procède par
élimination : si par exemple vous autorisez les touches F1 et F5 et que ni
l'indicateur 01 ni l'indicateur 05 ne sont à '1', c'est forcément que la touche
ENTREE a été enfoncée.
Dans l'écran ECRAN2, l'utilisateur aura le droit d'utiliser les touches de fonction
F7 et F24.
La fonction utilisée n'est plus CA comme dans l'écran ECRAN1, mais CF. La
différence est minime : dans la fonction CF les données en entrée (saisies) sont
transmises à l'unité centrale, alors qu'elles ne le sont pas dans le cas de la fonction
CA.
De toute façon, il est rare de prendre en compte les données en entrée lorsqu'on
utilise une touche de fonction. On préférera donc en général le mot clé CA.
Remarquez que la touche de fonction F1 a été autorisée pour tout le fichier, c'est-
à-dire pour tous les formats du fichier. En effet, elle a été codée avant le premier
format d'écran.

7.4. Les attributs d'affichage
SDD donn. décim
CA01( 01 )
R ECRAN1 CA03( 03 )
E1MAT 4 B 10 30 DSPATR(HI UL)
R ECRAN2 CF07( 07 )
CF24( 24 )
8 10 'Matricule:'
10 10 'Nom:'
12 10 'Salaire:'
E2MAT 4 O 8 20
E2NOM 20 O 10 20 COLOR(BLU)
E2SAL 10 Y 2 O 12 20 DSPATR(BL)
7.4.1. Fonction DSPATR
Champ E1MAT
On souhaite afficher ce champ en sur-brillance et en souligné.

C'est pourquoi on a mis la fonction DSPATR(HI UL)
Champ E2SAL
Ce champ sera affiché en clignotant. On voit donc que, pour spécifier des attributs
particuliers d'affichage, on utilise la fonction DSPATR avec un ou plusieurs codes
d'affichage.

En voici la liste :
UL = underline = souligné
HI = high intensity = double brillance
BL = blinking = clignotant
CS = cursor separator = séparation des caractères
par une barre verticale fine
ND = non display = non affichable, pour les
mots de passe par exemple
PC = position cursor = le curseur sera positionné
sur le champ spécifié
RI = reverse image = inversion vidéo
MDT = modified data tag = forcer à '1' l'indicateur
interne MDT du champ.
Cet indicateur est géré par
le système. Il est
habituellement à '1'
si l'utilisateur a modifié le
champ concerné et à '0'
sinon.
7.4.2. Fonction COLOR
Sur écran couleurs, on peut choisir la couleur des champs. La fonction à utiliser
n'est pas DSPATR mais COLOR. Par exemple le champ E2NOM s'affichera en
couleur bleue.
Voici les couleurs possibles :
BLU bleu
GRN vert
WHT blanc
RED rouge
TRQ turquoise
YLW jaune
PNK rose

7.4.3. Contrôles de présence et de validité
SDD donn. décim
CA01( 01 )
R ECRAN1 CA03( 03 )
1 25 'MISE A JOUR DU PERSONNEL'
E1MAT 4 B 10 30 COMP( GE '1000' )
CHECK(MF)
R ECRAN2 CF07( 07 )
CF24( 24 )
8 10 'Matricule:'
10 10 'Nom:'
12 10 'Salaire:'
14 10 'Sexe:'
E2MAT 4 O 8 20
E2NOM 20 B 10 20 CHECK( ME LC )
E2SAL 10 Y 2 B 12 20 RANGE( 5200.25 45678 )
E2SEX 1 B 14 20 VALUES( 'F' 'M' )
Vous pouvez constater la présence de fonctions nouvelles. Ce sont des fonctions

de contrôle des champs saisis par l'utilisateur.
Ils ne seront donc plus à programmer en GAP ou en COBOL, car ce sera le

système d'exploitation ou le terminal lui-même qui effectueront les contrôles
demandés.
Champ E1MAT
On vérifie tout d'abord à l'aide de la fonction COMP que le matricule saisi dans ce
champ est supérieur ou égal à '1000'. Le comparateur GE a été utilisé, mais les
autres comparateurs habituels restent bien sûr utilisables, ce sont : EQ, NE, GT,
GE, LT, LE, NL, NG
On vérifie ensuite par la fonction CHECK que la zone est remplie complètement,
c'est-à-dire que l'utilisateur a bien rempli les 4 caractères.
C'est le rôle du paramètre MF, qui signifie "mandatory fill", c'est-à-dire
"remplissage obligatoire" ou encore "tout ou rien".

Champ E2NOM
On vérifie par la fonction COMP que l'utilisateur a bien entré au moins un

caractère dans ce champ, grâce au paramètre ME qui veut dire "mandatory entry",
c'est-à-dire saisie obligatoire.
Le paramètre LC permet d'autoriser la frappe de lettres minuscules (LowerCase).
Champ E2SAL
Le salaire doit être compris entre 5200,25 F et 45678 F.
Champ E2SEX
Le code sexe doit être égal à 'F' ou à 'M'.
7.4.4. Fonction CHECK

Reprenons la fonction CHECK. Nous y avons mis les paramètres suivants :
LC lowercase = autorisation des minuscules

ME mandatory entry = saisie obligatoire
MF mandatory fill = remplissage obligatoire
Mais d'autres paramètres peuvent être écrits dans la fonction CHECK :
AB allow blanks = autorise la zone à blanc

ER end of record = déclenche la touche entrée en fin
de zone
FE field exit = obligation d'appuyer sur "fin de
zone"
pour passer au champ suivant
RB right blank = cadrage automatique du champ à
droite
avec remplissage automatique par
des blancs à gauche
RZ right zero = cadrage automatique du champ à
droite avec remplissage
automatique par des zéros à
gauche

7.5. Les codes d'édition
Nous allons voir maintenant comment afficher "agréablement" des données
numériques en sortie. Retenez bien : NUMERIQUES et en SORTIE seulement.
SDD donn. décim
CA01( 01 )
R ECRAN1 CA03( 03 )
E1MAT 4 B 10 30 COMP( GE '1000' )
CHECK(MF)
R ECRAN2 CF07( 07 )
CF24( 24 )
8 10 'Matricule:'
10 10 'Nom:'
12 10 'Salaire:'
14 10 'Sexe:'
E2MAT 4 O 8 20
E2SAL 10 Y 2 B 12 20 RANGE( 5200.25 45678 )
E2SEX 1 B 14 20 VALUES( 'F' 'M' )
R ECRAN3
E3MO1 6 Y 2 O 5 13 EDTCDE(K)
E3MO2 6 Y 2 O 6 13 EDTWRD(' , ')
E3MO3 6 Y 2 O 7 13 EDTWRD(' , &-&Francs')
Nous avons ajouté un écran ECRAN3 pour les besoins de la cause, avec deux
fonctions EDTCDE et EDTWRD. Ces deux fonctions ne doivent pas être tout à
fait nouvelles pour vous puisque nous les avons déjà rencontrées dans les fichiers
d'impression.
Etudions les trois champs concernés.
Champ E3MO1
Le code d'édition K fait partie des codes standards d'édition (ou encore de
formatage) de zone. Les codes d'édition standard, ou "edit codes" sont à choisir
parmi les suivants :

- les chiffres de 1 à 4;
- les lettres de A à D;
- les lettres de J à M;
- les lettres de X à Z.
Chacun de ces codes a la particularité d'afficher la virgule, ou le signe, ou des

blancs à gauche, etc.
Regardez dans la brochure "DDS Reference" le descriptif de chacun.
De plus, les codes 5 à 9 peuvent être définis par le programmeur lui-même, une
fois pour toutes.
Champ E3MO2
Ici, on utilise non plus un code d'édition, mais un mot d'édition. Les mots d'édition
ou "edit words" sont à utiliser si l'on n'arrive pas trouver un code d'édition qui
convienne.
Alors, vous pouvez personnaliser vos "edit words" qui correspondront exactement
à vos besoins.
Par exemple, E3MO2 sera affiché avec une virgule et sans signe.
Champ E3MO3
Ce champ qui utilise un autre "edit word" s'affichera avec le signe, s'il est négatif,
et suivi du mot "Francs".
Les signes "&" servent à ménager un blanc à l'endroit désiré.

7.6. Conditionnement par indicateurs
Voyons maintenant comment conditionner des champs ou des fonctions par des
indicateurs. Ces indicateurs seront mis à '0' ou à '1' par votre programme, qui
"télécommandera" en quelque sorte le fichier écran.
SDD donn. décim
CA01( 01 )
R ECRAN1 CA03( 03 )
E1MAT 4 B 10 30 COMP( GE '1000' )
CHECK(MF)
R ECRAN2 CF07( 07 )
CF24( 24 )
69 ALARM
8 10 'Matricule:'
10 10 'Nom:'
12 10 'Salaire:'
14 10 'Sexe:'
E2MAT 4 O 8 20
E2SAL 10 Y 2 B 12 20 RANGE( 5200.25 45678 )
E2SEX 1 B 14 20 VALUES( 'F' 'M' )
64 R ECRAN3 CA03(03)
68 E3MO2 6 Y 2 O 6 13 EDTWRD(' , ')
Voici à quoi servent les indicateurs utilisés ici.
Le format d'écran ECRAN2 produira un BIP sonore à chaque fois qu'il s'affichera,
à condition que l'indicateur 69 ait été positionné à '1' par le programme.
Dans l'écran ECRAN3, la touche fonction F3 ne sera utilisable que si l'indicateur

64 a été mis à '1' par le programme.
Dans ce même écran, le champ E3MO2 ne s'affichera que si l'indicateur 68 a été

mis à '1' par le programme.

7.7. Gestion des messages d'erreur
SDD donn. décim
CA01( 01 )
R ECRAN1 CA03( 03 )
E1MAT 4 B 10 30 COMP( GE '1000' )
CHECK(MF)
E1MSG 60 O 24 5
R ECRAN2 CF07( 07 )
CF24( 24 )
69 ALARM
8 10 'Matricule:'
10 10 'Nom:'
12 10 'Salaire:'
14 10 'Sexe:'
E2MAT 4 O 8 20
E2SAL 10 Y 2 B 12 20 RANGE( 5200.25 45678 )
E2SEX 1 B 14 20 VALUES( 'F' 'M' )
62 24 18 'Salaire inadapté au travail fourni !'
64 R ECRAN3 CA03(03)
68 E3MO2 6 Y 2 O 6 13 EDTWRD(' , ')
65 ERRMSG('Montant trop grand')
66 ERRMSGID(MES1234 FICHMESS)
Vous voulez des messages d'erreur du genre "Article absent", "Stock insuffisant"
ou encore "Espèce d'ornithorynque ! ". Une fois votre choix effectué en ce qui
concerne le nom d'animal attribué à l'utilisateur, vous pouvez utiliser une méthode
que je qualifierai de "traditionnelle". Elle consiste à déclarer dans votre écran un
champ en sortie, et d'y mettre par programme le message désiré, ou bien des
espaces quand le message ne doit pas être affiché.
Vous en avez un exemple avec le champ E1MSG de l'écran ECRAN1.
Dans le cas où l'utilisateur n'a pas fait d'erreur, le champ message E1MSG sera à
remettre à blanc par votre programme.

Une variante, que je baptiserai méthode "semi-traditionnelle", consiste à définir
dans les SDD un champ constant, cette fois-ci, qui contient le texte du message.
C'est ce que l'on trouve dans l'écran ECRAN2.
Pour que ce texte n'apparaisse pas systématiquement, même en cas de non-erreur,
il suffira de conditionner l'affichage de ce champ constant par un indicateur, qui
sera positionné à '0' ou à '1' dans le programme, selon s'il y a eu erreur ou pas.
Une troisième méthode, "semi-moderne", va utiliser la fonction ERRMSG. Le

message s'affichera systématiquement sur la 24e ligne de l'écran.
Cette méthode diffère de la méthode "semi-traditionnelle" surtout par le fait que le

clavier du terminal sera bloqué, jusqu'à ce que l'utilisateur ait la bonne idée
d'appuyer sur la touche "Restauration après erreur", bonne idée qu'il n'a
généralement qu'après vous avoir dérangé par téléphone, en plein début d'une
excellente sieste bien méritée.
De plus, le message peut venir en superposition d'une ligne d'écran non vide.
Cette ligne sera automatiquement restaurée dès la disparition du message.
Dans l'exemple ci-dessus, le message "Montant trop grand" s'affichera

automatiquement si vous avez positionné à '1' l'indicateur 65 lorsque vous affichez
le format d'écran ECRAN3.
La quatrième méthode est résolument "moderne". C'est une variante du ERRMSG

précédent, elle utilise le système des fichiers de messages de l'OS/400. Les
fichiers de messages sont des objets complètement externes à votre programme et
à votre fichier écran.
Vous pouvez vous créer vous-même vos propres fichiers de messages, qui sont en
fait de simples listes de messages. Vous aurez ainsi très facilement la possibilité
de vous constituer plusieurs versions de votre fichier message en différentes
langues : français, allemand, anglais.
Il vous faudra créer le fichier message par l'ordre CL :
CRTMSGF
Puis vous ajouterez des messages dans votre fichier à l'aide de l'ordre CL :
ADDMSGD
ou encore :
WRKMSGD

Sachez que chaque message est identifié par son code message sur 7 caractères.
Ensuite, vous coderez dans vos SDD d'écran une ligne avec la fonction
ERRMSGID comme en fin d'écran ECRAN3.
Ici, MES1234 est le code message à 7 caractères, et FICHMESS est le nom du

fichier de messages.
7.8. Autres possibilités
SDD donn. décim
CA01( 01 )
R ECRAN1 CA03( 03 )
PRINT
E1MAT 4 B 10 30 COMP( GE '1000' )
CHECK(MF)
R ECRAN2 CF07( 07 )
CF24( 24 )
CSRLOC(X Y)
3 30 'Le : '
3 36 DATE EDTCDE(Y)
8 10 'Matricule:'
10 10 'Nom:'
12 10 'Salaire:'
14 10 'Sexe:'
E2MAT 4 O 8 20
E2SAL 10 Y 2 B 12 20 RANGE( 5200.25 45678 )
E2SEX 1 B 14 20 VALUES( 'F' 'M' )
7.8.1. Fonction CSRLOC

Dans l'écran ECRAN2, le curseur se positionnera d'emblée dans le champ E2SAL
de coordonnées X et Y sur l'écran, et non pas comme d'habitude sur le premier
champ à saisir, c'est-à-dire E2NOM.
X est le numéro de ligne, et Y le numéro de colonne sur l'écran.

Ce peut être utile dans certains cas où on veut éviter à l'utilisateur de sauter à l'aide
de la touche "fin de zone" un certain nombre de zones qu'il n'a rarement ou jamais
à remplir, ou pour positionner le curseur sur une zone à corriger par l'utilisateur.
C'est la fonction CSRLOC définie au niveau du format d'écran (et non au niveau
champ) qui est à utiliser.
7.8.2. Fonctions DATE et TIME
On a placé en troisième ligne de l'écran ECRAN2 la date système interne de

l'ordinateur. Remarquez que l'on a utilisé le code d'édition Y spécialement adapté
aux dates à 6 caractères.
De la même façon, la fonction TIME affichera l'heure système.
7.8.3. Fonction PRINT
Cette fonction indique que l'écran ECRAN1 pourra être imprimé tel quel si
l'utilisateur appuie sur la touche PRINT du clavier. L'impression donnera lieu à un
fichier d'impression classique qui sera appelé QSYSPRT et qui se rangera en file
d'attente de spool.
7.8.4. Les touches interceptables par un programme

D'autres touches du clavier peuvent être interceptées par votre programme, en
utilisant les fonctions appropriées :
HELP
ROLLUP
ROLLDOWN
HOME
CLEAR

7.9. Utiliser les fichiers écran en GAP
Considérons un programme qui affiche une première image écran sur laquelle on
demande à l'utilisateur de taper un code article. C'est l'image écran E1.
Puis, le programme reçoit le code article saisi par l'utilisateur, consulte le fichier
article, et enfin affiche à l'utilisateur une image écran E2 lui fournissant toutes les
caractéristiques de l'article demandé.
C'est un programme d'interrogation tout à fait classique.
Comment programmer en GAP par exemple l'affichage du format d'écran E1 ?

Ce n'est pas compliqué. Nous avons dit que les fichiers écran étaient gérés
sensiblement comme des fichiers de données sur disque. Or quel ordre rédige-t-on
pour programmer une écriture sur un fichier disque ?
L'ordre WRITE bien sûr. Donc pour afficher un format d'écran sur un terminal, il
suffira d'écrire un ordre WRITE de ce format. Exemple :
WRITE E1
Mais ce n'est pas tout, car l'ordre WRITE ne fait qu'afficher l'écran E1, puis le
programme continue à s'exécuter sans laisser la moindre fraction de seconde à
notre pauvre utilisateur pour saisir son code article. C'est normal, car l'ordre
WRITE n'est qu'un ordre d'écriture.
Il faut le faire suivre d'un ordre de lecture des données saisies par l'utilisateur.
Comme pour les fichiers de données, c'est un ordre READ qu'il faudra écrire dans
votre programme, juste après l'ordre WRITE. Alors le programme s'arrêtera sur
l'exécution de l'ordre READ. Il attendra tout le temps qu'il faut jusqu'à ce que
l'utilisateur appuie sur la touche ENTREE ou sur l'une des touches suivantes si
toutefois elles sont autorisées :
- F1 à F24
- AIDE
- HOME
- CLEAR
- PRINT
- ROLLUP
- ROLLDOWN
Cela nous donnera :

WRITE E1
READ E1
Mais IBM, voulant éviter des efforts aux programmeurs, propose l'ordre EXFMT,
qui effectue en un seul ordre un WRITE suivi d'un READ.
Les deux lignes de programmation ci-dessus sont équivalentes à la ligne ci-
dessous :
EXFMT E1
Cet ordre EXFMT permet donc l'opération classique d'envoi d'une image-écran
sur un terminal, et d'attente de la réponse de l'utilisateur.
Restent bien sûr à votre charge :
- avant l'EXFMT de remplir les champs variables à afficher, et les indicateurs de

condition (éventuels),
- après l'EXFMT de tester la valeur des indicateurs associés aux touches de

fonction (s'il y a lieu) et d'exploiter les données saisies par l'utilisateur.

8. Les sous-fichiers
8.1. Le but des sous-fichiers
Pour expliquer à quoi servent les sous-fichiers, partons d'un cas concret.
Un exemple de dialogue
Supposons que l'on vous demande d'afficher sur écran la liste des salariés d'un
service donné.
Votre fichier du personnel s'appelle PERS et chaque enregistrement contient les

rubriques suivantes :
Fichier du personnel PERS
PESER code du service 2 caractères

PEMAT matricule 3 caractères
PENOM nom du salarié 20 caractères
Il est indexé sur le code service, et sur le matricule. Voici ce que pourrait être le
contenu de ce fichier :

PESER PEMAT PENOM
01 001 Nicolas
01 002 Poinsignon
02 001 Arnould
02 002 Muller
02 003 Stock
02 004 Couturier
. . .
. . .
. . .
. . .
36 001 Friedrich
36 002 Gonzales
36 003 Valette
. . .
. . .
36 010 Jean
36 011 Demange
. . .
. . .
36 019 Durieux
36 020 Lemaire
36 021 Potier
36 022 Henry
37 001 Lepicard
37 002 Mangin
-------------------- FIN DU FICHIER ----------------------
Et vous voudriez programmer le dialogue suivant :

C'est un programme d'interrogation tout à fait courant dans les services
informatiques, et tout informaticien digne de ce nom doit donc être capable de le
réaliser. Bien sûr, la nouveauté consiste ici à afficher une liste qui est trop longue
pour tenir sur un seul écran.
Dans notre exemple, nous avons décidé de fixer à 10 le nombre de lignes maximal
qui peut être affiché sur l'écran 2.
Si tous les services de l'entreprise n'avaient pas plus de 10 salariés, il n'y aurait
aucun problème. Nous aurions affaire à un programme d'interrogation classique.
Malheureusement, le service numéro 36 contient 22 personnes !
Après avoir demandé le numéro de service à interroger sur l'écran 1, le

programme affichera la première "page écran" de la liste, c'est-à-dire les salariés
de 001 à 010.
Le programme devra donner la possibilité à l'utilisateur de visualiser les pages-

écran suivantes à l'aide de la touche ROLLUP (salariés de 011 à 020, puis de 021
à 022).
Mais il faut aussi donner à l'utilisateur la possibilité de revenir en arrière sur les
pages-écran précédentes. Il utilisera pour cela la touche ROLLDOWN de
pagination arrière.
Voila pour ce qui est du dialogue-écran dont doit disposer votre futur bienheureux
utilisateur.
La méthode sans sous-fichiers
Si vous êtes sur toute machine autre que l'AS/400, donc une machine qui ne vous
permet pas d'utiliser la technique des sous-fichiers, vous devrez procéder de la
façon suivante.
D'abord, il faut déclarer dans votre écran 2, les rubriques matricule et nom pour
chacune des dix lignes d'écran.
Elles porteront par exemple les noms :
ECMAT1 ECNOM1
ECMAT2 ECNOM2
ECMAT3 ECNOM3
ECMAT4 ECNOM4
ECMAT5 ECNOM5
ECMAT6 ECNOM6
ECMAT7 ECNOM7
ECMAT8 ECNOM8
ECMAT9 ECNOM9
ECMAT10 ECNOM10

Cela fait tout de même 20 rubriques à déclarer !
Et c'est un cas d'école, car on a plus souvent 20 lignes à afficher plutôt que 10 et,
dans chaque ligne, 6 ou 7 rubriques plutôt que 2.
On atteint ainsi facilement les 100 à 200 rubriques d'écran à déclarer.
C'est une première limite du système classique; signalons toutefois qu'elle peut
être partiellement contournée par la technique des tableaux.
Votre programme ayant à gérer les touches ROLLUP et ROLLDOWN, il vous

faudra programmer les actions ou modules suivants :
ACTION : affichage de la page-écran suivante
- reprendre la lecture du fichier personnel à l'endroit où l'on était arrêté;

- remplir une à une chacune des 10 lignes d'écran, tant que l'on est pas en fin
d'écran, ou en fin de service, ou en fin de fichier.
ACTION : affichage de la page-écran précédente
- relire en arrière 20 enregistrements (10+10) dans le fichier du personnel, tant que

l'on n'est pas en début de service, ou en début de fichier;
- reprendre la lecture du fichier personnel en marche avant pour remplir une à une
chacune des 10 lignes d'écran, tant que l'on est pas en fin d'écran, ou en fin de
service, ou en fin de fichier.
Vous devez réaliser que tout cela n'est pas très simple à programmer.
Et c'est pourtant le lot quotidien des pauvres analystes-programmeurs qui ne
disposent pas de la technique des sous-fichiers dans leur système d'exploitation !
8.2. Le principe des sous-fichiers
Sur l'IBM38 puis sur l'AS/400, IBM a intégré au système d'exploitation le

principe des sous-fichiers dans le but d'alléger considérablement les programmes
qui affichent des listes.

Et c'était vraiment nécessaire, car ces programmes sont devenus extrêmement
fréquents dans les applications informatiques actuelles. Cette fonction de l'OS/400
est disponible en GAP et en COBOL.
Mais qu'est-ce qu'un sous-fichier ?
C'est un fichier spécial qui va servir d'intermédiaire entre votre fichier du

personnel et votre fichier-écran lorsque l'utilisateur affichera l'écran 2. Voyez sur
le schéma ci-après comment ce sous-fichier peut s'intercaler entre le programme et
l'écran proprement dit.

Oui, mais comment ça marche ?
Alors là, installez-vous confortablement, détendez-vous, et concentrez-vous, le

passage qui suit va être délicat !
Au début du programme, rien de changé, l'écran 1 s'affiche, sans utiliser du tout le

sous-fichier.
Puis lorsque le programme veut afficher l'écran 2 avec les salariés 001 à 010, il ne
va pas remplir les 20 zones-écran comme nous l'avons vu précédemment.
Affichage de la première page-écran
Non, il va écrire les 10 lignes d'affichage dans le sous-fichier à raison d'une ligne
d'affichage par enregistrement.
Tout comme on ajoute de nouveaux enregistrements dans un fichier.
Votre programme va ensuite effectuer un EXFMT normal de l'écran 2.
L'EXFMT assure automatiquement une lecture des 10 enregistrements du sous-

fichier qui vient d'être écrit, et un affichage des 10 lignes sur l'écran.
8.2.1. Affichage des pages-écran suivantes

Ensuite l'utilisateur appuie sur ROLLUP pour voir la suite de la liste.
Votre programme qui a intercepté le ROLLUP va devoir ajouter les 10 salariés

suivants (du 011 au 020) au sous-fichier qui va maintenant contenir 20
enregistrements.
Cet ajout de 10 enregistrements se fera comme ci-dessus, c'est-à-dire par un jeu de

lectures du fichier PERS et d'écritures dans le sous-fichier.
Une fois cela réalisé, le programme va effectuer bien sûr un EXFMT de l'écran 2.
Et, automatiquement, les 10 enregistrements suivants du sous-fichier vont être
affichés.
8.2.2. Affichage des pages-écran précédentes

Supposons maintenant que l'utilisateur veuille revenir en arrière pour réafficher les
salariés 001 à 010.
Il appuie sur la touche ROLLDOWN, et là c'est vraiment magique, car c'est le
système d'exploitation qui prend tout en charge.

Il va reculer automatiquement de 20 (= 10+10) enregistrements dans le sous-
fichier (attention, pas dans le fichier PERS), puis il va afficher, automatiquement
aussi, l'écran 2 avec les salariés 001 à 010.
Sachez que votre programme n'aura pas du tout à gérer la touche ROLLDOWN, je
répète car vous n'en croyez certainement pas vos jeunes oreilles d'informaticien,
vous n'aurez rien à programmer pour le cas où l'utilisateur appuie sur
ROLLDOWN !
Récapitulons : vous n'aurez à programmer que le remplissage de la première page

du sous-fichier, et aussi le remplissage des pages suivantes par la touche
ROLLUP.
8.3. Les SDD d'un sous-fichier
Comme d'habitude, nous allons devoir décrire notre fichier-écran à l'aide de SDD,
afin de pouvoir le créer par compilation ensuite. Et, comme d'habitude aussi, les
SDD pourront ou bien être saisies avec SEU, ou bien être générées
automatiquement par SDA. A vous de choisir la méthode qui vous convient le
mieux. Mais, pour faire un choix, il faut essayer.
Il est donc fortement conseillé de tester suffisamment longuement les deux

méthodes, et de faire ensuite un choix réellement motivé.
Le fichier-écran de notre programme va devoir décrire deux écrans : l'écran 1 et

l'écran 2. Pour l'écran 1, aucun problème, il donnera lieu comme d'habitude à un
format d'écran que nous appellerons ECRAN1.
Pour l'écran 2, qui fait donc appel à un sous-fichier, nous devrons définir non pas
un, mais deux formats d'écran. En premier lieu, il faudra définir ce que l'on
appelle le format d'enregistrement de l'écran 2.
C'est le format qui décrit une des lignes d'affichage du sous-fichier. Vous avez
bien lu, on ne décrit qu'une seule ligne, et non pas chacune des 10 lignes, c'est tout
de même plus rapide !
On nommera ce format : ECRAN2E . Le choix du nom n'est bien sûr pas imposé
par l'OS/400, mais, pour des raisons de clarté, il est préférable qu'il se termine par
un E, comme Enregistrement.
En second lieu, on définira le format de contrôle de l'écran 2. Ce format permet de

décrire l'en-tête de l'écran (ou le bas de l'écran), ainsi que des paramètres généraux
du sous-fichier. On appellera ici ce format ECRAN2C , le C signifiant évidement
Contrôle.
Voici comment écrire les SDD de notre programme :

SDD donn. décim
R ECRAN1
1 25 'INTERROGATION DU +
PERSONNEL'
10 5 'Tapez le code du service :'
E1SER 2 B 10 40
R ECRAN2E SFL
E2MAT 3 O 6 10
E2NOM 20 O 6 15
R ECRAN2C SFLCTL(ECRAN2E)
SFLPAG(10)
SFLSIZ(11)
61 SFLCLR
N61 SFLDSP
N61 SFLDSPCTL
ROLLUP(31)
WRANG 4 0 H SFLRCDNBR(CURSOR)
1 35 'LISTE DES SALARIES'
4 10 'Matr'
4 15 'Nom'
Commentons. Pour l'écran 1, rien à signaler comme prévu. Pour l'écran 2, nous
avons bien les deux formats ECRAN2E et ECRAN2C.
8.3.1. La fonction SFL
Le format ECRAN2E décrit seulement la première des 10 lignes de salariés. Elle

se trouve en sixième ligne de l'écran, et comporte les deux rubriques E2MAT et
E2NOM.
Le seul paramètre particulier est la fonction SFL, qui indique qu'il s'agit d'un sous-
fichier : SFL est l'abréviation de Sub-FiLe.

8.3.2. La fonction SFLCTL
Le format ECRAN2C décrit l'en-tête de l'écran 2, ainsi que certains paramètres du

sous-fichier.
La fonction SFLCTL permet de dire à l'OS/400 que le format ECRAN2C est le

format de contrôle du format d'enregistrement ECRAN2E. Il assure la liaison
entre les deux noms.
8.3.3. La fonction SFLPAG
La fonction SFLPAG indique le nombre de lignes répétitives sur l'écran. Nous

avons décidé de mettre 10 salariés par écran, d'où le SFLPAG(10).
Ce nombre peut varier de 1 à 24.
Une petite remarque en passant : vous avez certainement déjà eu des messages
d'erreur en bas d'écran avec un signe "+" à droite. C'est tout simplement que cette
ligne de message est en fait un sous-fichier un peu particulier qui n'a qu'une ligne
en hauteur, qui a donc été défini avec la fonction SFLPAG(1).
Pour essayer de faire fonctionner ce petit sous-fichier, placez votre curseur en bas
de l'écran sur un message d'erreur qui présente un signe "+" à sa droite, et vous
pourrez paginer sur ce message avec les touches ROLLUP et ROLLDOWN.
8.3.4. La fonction SFLSIZ
La fonction SFLSIZ indique le nombre d'enregistrements maximal du sous-

fichier.
Mais comme la taille du sous-fichier est étendue automatiquement au fur et à
mesure de son remplissage, ce paramètre peut avoir n'importe quelle valeur
pourvu qu'elle ne soit pas égale au SFLPAG.
S'il y a égalité, le sous-fichier est géré en mode statique, qui est moins avantageux
que le mode dynamique que nous étudions ici.
Dans la pratique, il est conseillé d'indiquer un SFLSIZ égal au SFLPAG + 1.
Dans tous les cas, le sous-fichier ne pourra contenir plus de 9 999 enregistrements.

8.3.5. La fonction SFLCLR
Vous voyez que cette fonction est associée à un indicateur.

Si cet indicateur est positionné à ON par votre programme, et que vous envoyez
un ordre WRITE en GAP sur ce sous-fichier, alors, il y aura effacement de tous
les enregistrements du sous-fichier.
Il s'agit en fait d'une technique pour effacer le contenu d'un sous-fichier. SFLCLR
signifie Sub-FiLe CLeaR.
Vous en aurez besoin lorsque après avoir interrogé le service 36, l'utilisateur
voudra interroger le service 20 par exemple.
Si vous ne videz pas le sous-fichier, tous les salariés du service 36 resteront dans
le sous-fichier et les salariés du service 20 viendront se mettre à la suite.
Et, en paginant sur le service 20, l'utilisateur va retrouver des salariés du service
36. Quelle pagaille !
Récapitulons.
Vous aurez besoin à certains endroits de votre programme d'effacer votre sous-
fichier, avant de le remplir à nouveau avec d'autres données.
Pour l'effacer, il faudra écrire un ordre WRITE de l'écran 2 dans le programme
GAP, en ayant soin d'avoir préalablement positionné à ON l'indicateur associé à la
fonction SFLCLR.
Ne pas oublier de le remettre à OFF ensuite.
8.3.6. Les fonctions SFLDSP et SFLDSPCTL
Ces fonctions sont, elles aussi, associées à un indicateur.
SFLDSP est la fonction qui demande l'affichage des lignes du sous-fichier (format
d'enregistrement).
SFLDSPCTL est la fonction qui demande l'affichage du format de contrôle.
Si vous effectuez un ordre WRITE ou EXFMT de l'écran 2, et que l'indicateur

associé à SFLDSP ou SFLDSPCTL est à '0', l'affichage ne se produit pas.
Par contre, si l'indicateur associé est à '1', il y a affichage de l'écran 2. En pratique,

on ne positionnera à '0' l'indicateur associé que dans le cas où l'on veut effacer le
sous-fichier, comme nous venons d'en parler avec la fonction SFLCLR.
C'est la raison pour laquelle, dans l'exemple, on a préféré n'utiliser qu'un seul
indicateur, le numéro 61 qui sert d'indicateur d'effacement du sous-fichier.
S'il est à '1', le sous-fichier est effacé et il n'y a pas d'affichage, et s'il est à '0', le
sous-fichier n'est pas effacé et il y a affichage.

Les ordres GAP correspondants pour effacer le sous-fichier :
SETON 61
WRITE ECRAN2C
SETOF 61
Pour l'affichage normal du sous-fichier, on n'a pas besoin de remettre à OFF

l'indicateur 61, puisqu'il y est en temps normal. Un simple EXFMT suffit :
EXFMT ECRAN2C
8.3.7. La fonction ROLLUP
Cette fonction est une déclaration qui autorise l'utilisation de la touche ROLLUP,
et qui l'associe à l'indicateur 31. La fonction ROLLUP est tout à fait comparable
aux fonctions CAnn et CFnn des touches de fonction.
8.3.8. La rubrique de gestion du rang
Vous voyez apparaître dans le format de contrôle la rubrique WRANG qui n'y
était pas prévue initialement. A quoi sert-elle ?
Elle est indispensable pour le bon fonctionnement interne de la pagination par

l'OS/400. C'est une variable qui peut porter n'importe quel nom autre que
WRANG :
- elle doit être cachée, d'où le "H" en colonne type;

- elle doit contenir le numéro de la dernière ligne écrite dans le sous-fichier;
- elle doit apparaître dans le format de contrôle;
- elle doit être numérique de longueur 4;
- elle doit avoir la fonction SFLRCDNBR(CURSOR) , qui est l'abréviation
de SubFiLe ReCorD NumBeR (attention: CURSOR est un mot réservé IBM).

Si vous oubliiez cette variable WRANG, l'OS/400 ne vous afficherait que la
première page du sous-fichier.
Les trois dernières lignes de SDD servent à afficher le titre de l'écran, ainsi que les
deux en-têtes de colonnes.
Nous venons de voir les mots clés indispensables pour manipuler un sous-fichier.
Il y en a d'autres, d'usage moins fréquent. Vous trouverez tout de même parfois les
fonctions suivantes :
SFLEND pour afficher le petit signe + de continuation en bas à droite
SFLINZ pour initialiser à blanc ou à zéro tout les enregistrements

du sous-fichier
SFLLIN pour afficher en multicolonnes
SFLROLVAL pour indiquer le nombre de lignes de pagination.

Il est, par défaut, égal à SFLPAG.

8.4. Utiliser un sous-fichier dans un programme
GAP
8.4.1. Déclaration du sous-fichier
Comme tout fichier écran qui se respecte, un fichier écran qui contient un sous-
fichier doit être déclaré dans une spécification F.
Mais il va falloir ajouter une ligne supplémentaire juste après la spécification F

habituelle.
Cette ligne contiendra :
colonne 6 : F
colonne 47 : WRANG
colonne 53 : K
colonne 54 : SFILE
colonne 60 : nom du format d'enregistrement du sous-fichier
Notons que WRANG est un nom de variable au choix du programmeur, et qui

servira dans le programme à contenir le numéro de l'enregistrement en cours du
sous-fichier.
Ce doit donc être le même nom que celui de la variable associée à SFLRCDNBR
dans les SDD.
8.4.2. Comment préparer la première page ?
Voici comment peut être écrite la séquence de programme GAP qui prépare
l'affichage de la première page-écran d'un service interrogé :

Z-ADD 0 WRANG
SETON 61
WRITE ECRAN2C
SETOF 61
E1SER SETLL PERS 81

*IN81 IFEQ '1'
READ PERS 91
Z-ADD 0 WLIG
E1SER DOWEQ PESER
WLIG ANDLT 10
*IN91 ANDEQ '0'
ADD 1 WRANG
ADD 1 WLIG
MOVEL PEMAT E2MAT
MOVEL PENOM E2NOM
WRITE ECRAN2E
READ PERS 91
END
END
On y distingue trois groupes d'ordres.

Le premier groupe compte 4 ordres. Il sert à la remise à zéro du compteur de ligne
dans le sous-fichier, puis il efface le contenu du sous-fichier avant remplissage.
Le deuxième groupe compte 3 ordres. Il permet de positionner le fichier PERS sur

le premier salarié du service demandé.
Le troisième groupe compte 12 ordres. Il sert à écrire 10 enregistrements dans le

sous-fichier par une structure répétitive qui va s'exécuter tant que :
- le code service du fichier PERS est le même que celui demandé sur l'écran 1;
- et le nombre de lignes WLIG écrites ne dépasse pas 10;
- et on n'arrive pas en fin du fichier PERS.
Après cette belle séquence d'instructions, il suffira d'ajouter un EXFMT du format

ECRAN2C pour réaliser effectivement l'affichage sur écran.
La variable mémoire WRANG contient le numéro d'enregistrement du sous-

fichier, qui passera de 0 à 10 lors de l'affichage du premier écran, puis de 10 à 20

après le premier appui sur ROLLUP, et enfin de 21 à 22 après le deuxième appui
sur ROLLUP.
La variable mémoire WLIG, elle, ne varie que de 0 à 10, car elle sert à compter le
nombre d'enregistrements ajoutés dans le sous-fichier à chaque ROLLUP, c'est-à-
dire 10 au maximum.
Ne pas confondre avec WRANG, qui est le nombre d'enregistrements total du
sous-fichier.
L'indicateur 81 (colonnes 58 et 59) sera positionné à 1 si le service demandé

existe.
Ainsi, dans le cas où il n'existe aucun enregistrement pour le service demandé, on
n'entre pas dans la boucle, et on affiche un sous-fichier vide.
On aurait pu aussi modifier cette programmation pour afficher un message "Pas de
salariés dans ce service".
L'ordre WRITE écrit un nouvel un enregistrement dans le sous-fichier, attention

de bien spécifier le nom du format d'enregistrement (et non celui du format de
contrôle). Le résultat serait sensiblement différent !
8.4.3. Comment préparer les pages suivantes ?
Comme la première page, ou presque. Etudions la question plus en détail.

Lorsque l'utilisateur appuie sur la touche ROLLUP, votre programme reprend le
contrôle et doit afficher les 10 salariés suivants.
Il faut donc :
- surtout ne pas effacer les premiers enregistrements du sous-fichier... péniblement

créés lors de l'affichage de la première page, ni repositionner le fichier PERS,
- continuer la lecture du fichier PERS à l'endroit où elle était arrêtée, et ajouter les
10 enregistrements suivants (011 à 020) dans le sous-fichier;
- afficher l'écran 2 à l'aide d'un EXFMT;
Il ne restera, dans les lignes de programme écrites ci-dessus, que les dernières,
soit:

Z-ADD 0 WLIG
E1SER DOWEQ PESER
WLIG ANDLT 10
*IN91 ANDEQ '0'
ADD 1 WRANG
ADD 1 WLIG
MOVEL PEMAT E2MAT
MOVEL PENOM E2NOM
WRITE ECRAN2E
READ PERS 91
END
Notez bien qu'il faut remettre à zéro WLIG mais pas WRANG. On aura intérêt à
faire un sous-programme de cette séquence d'ordres GAP, qui sera appelé par un
ordre EXSR.
8.5. Mise à jour d'un sous-fichier par

l'utilisateur
Varions notre exemple. Supposons maintenant que l'utilisateur veuille modifier
l'orthographe de certains noms de salariés à l'aide de votre programme. Bien sûr, il
ne le peut pas actuellement, car le nom E2NOM est déclaré en O = output = sortie.
Vous allez donc commencer par le déclarer en B = both = entrée + sortie.
Maintenant l'utilisateur peut modifier les noms dans le sous-fichier.

Très bien, mais attention, j'ai bien dit dans le sous-fichier, je n'ai pas dit dans le
fichier PERS ! Ce serait trop facile ! Ce n'est pas parce que le sous-fichier est mis
à jour que le fichier PERS l'est aussi.
Vous voyez venir le problème : il va falloir que vous programmiez en GAP la

relecture du sous-fichier du premier au dernier enregistrement, et pour chaque
salarié dont le nom aura été modifié par l'utilisateur, il vous faudra faire une mise
à jour du fichier PERS à l'aide d'un simple ordre UPDAT sur PERS.
Heureusement, vous n'aurez pas besoin de relire tous les enregistrements du sous-
fichier, car on dispose en GAP de l'ordre READC (= read changed).
L'ordre READC est un ordre de lecture séquentielle, comme l'ordre READ.

Mais si l'ordre READ signifie "lire l'enregistrement suivant", l'ordre READC
signifie "lire le prochain enregistrement qui a été modifié par l'utilisateur". Il va
donc "sauter" tous les enregistrements non modifiés par l'utilisateur.

Une petite réserve toutefois. Supposons que notre bien-aimé utilisateur ait modifié
le contenu d'une rubrique dans une ligne de sous-fichier, puis saisi d'un profond
remords, il remet dans cette rubrique le contenu initial, sans avoir validé entre-
temps par la touche Entrée.
Eh bien, dans ce cas, la rubrique sera considérée comme ayant été modifiée, alors
qu'en fait elle conserve le même contenu. Le READC s'y arrêtera donc, mais ce
n'est pas grave car votre programme fera une mise à jour de l'enregistrement du
fichier PERS en y remettant le même nom : ce n'est qu'un "coup pour rien".
Voici ce que peut donner la séquence d'instructions chargée de la mise à jour du

fichier PERS à partir du sous-fichier modifié par l'utilisateur :
READC ECRAN2E 92
*IN92 DOWEQ '0'
E2MAT CHAIN PERS 82
N82 MOVEL E2NOM PENOM
N82 UPDAT PERS
READC ECRAN2E 92
END
L'indicateur 92 se déclenche en fin de sous-fichier.
Le CHAIN sur PERS permet de lire le salarié concerné.

Le MOVEL met à jour la rubrique nom du fichier PERS.
L'ordre UPDAT réécrit l'enregistrement du fichier PERS.
L'indicateur 82 (enregistrement non trouvé) ne doit en principe jamais être à ON,
mais par précaution on conditionne la mise à jour de PERS par cet indicateur.
Avant de passer à la suite, je voudrais vous parler d'un autre exemple de sous-
fichier en mise à jour, car c'est un exemple extrêmement courant.
Vous voulez donner la possibilité à l'utilisateur de "cocher" un (ou plusieurs)

salarié(s) figurant sur le sous-fichier, afin d'afficher sur une autre image-écran
(l'écran 3) des informations concernant par exemple la paie du (ses) salarié(s)
coché(s).
C'est exactement le système qu'IBM utilise dans la commande WRKSPLF par
exemple.
Vous allez tout simplement ajouter une rubrique d'un caractère de large dans le
format d'enregistrement ECRAN2E.
Cette rubrique sera de type B (input + output). Nous l'appellerons par exemple
E2SEL, comme sélection.

L'utilisateur pourra donc y saisir un caractère de sélection. On choisit
habituellement le chiffre "1" comme caractère de sélection dans les normes SAA.
Donc, s'il tape un "1" en face d'un salarié, votre programme sera tout à fait capable
de retrouver à l'aide d'un READC le (ou les) enregistrements de sous-fichier ainsi
cochés.
Il pourra ensuite afficher l'écran 3 avec les détails de paie du salarié coché.

8.6. Mise à jour d'un sous-fichier par le
programme
Voyons une autre possibilité d'utiliser les sous-fichiers. Votre programme peut lui-
même modifier tel ou tel enregistrement du sous-fichier. Assurez-vous de ne pas
faire la confusion avec le cas précédent.
Tout à l'heure, le sous-fichier était mis à jour par l'utilisateur lui-même. Et votre
programme mettait à jour le fichier, pas le sous-fichier.
Maintenant, c'est différent, c'est votre programme qui va modifier un ou plusieurs

enregistrements du sous-fichier, afin de le réafficher ensuite.
Exemple:
Reprenons celui que nous venons juste de voir, celui qui donne la possibilité de
cocher un salarié pour visualiser sa paie sur un écran 3.
Si, après avoir visualisé l'écran 3, vous réaffichez le sous-fichier, le chiffre "1"
saisi dans la rubrique E2SEL restera toujours à "1" puisque personne ne l'a remis à
blanc.
Il faudra donc que l'utilisateur retrouve la ligne concernée en paginant avec

ROLLUP et ROLLDOWN, puis qu'il efface le "1", et qu'il saisisse un "1" sur un
autre salarié pour afficher la paie de cet autre salarié. Compliqué !
Vous pouvez lui simplifier le travail, en mettant dans votre programme des ordres
qui vont remettre à blanc la rubrique E2SEL de l'enregistrement concerné du sous-
fichier.
C'est simple, quand vous êtes positionné sur le bon enregistrement du sous-fichier
par un READC, il suffit d'écrire :
MOVE *BLANK E2SEL

UPDAT ECRAN2E
C'est une simple mise à jour du sous-fichier.

Quand vous le réafficherez à l'aide d'un EXFMT, vous verrez que ça marche ! Le
chiffre "1" aura disparu. Notez le mot *BLANK dans la zone facteur2. C'est ce
que l'on appelle une constante figurative, c'est un mot réservé qui remplace la
constante ' '.

8.7. L'OVERLAY dans les sous-fichiers
Malheureusement, quand vous définissez votre format de contrôle, vous ne

pouvez pas placer des champs à la fois au dessus et au dessous des lignes du sous-
fichier. Il faut choisir entre le haut et le bas.
La pratique courante consiste à définir :
- le format de contrôle du sous-fichier qui contiendra le haut de l'écran, c'est-à-dire

en général :
- le titre de l'écran
- éventuellement les valeurs possibles des options
- les en-têtes des colonnes du sous-fichier
- le format d'enregistrement du sous-fichier
- un format supplémentaire de bas d'écran, qui permet d'afficher habituellement :
- les touches fonction possibles

- les messages d'erreur éventuels
Mais ce format supplémentaire ne s'affichera pas par l'EXFMT du sous-fichier.
Vous devez en premier afficher ce format de bas d'écran par un ordre WRITE, et
immédiatement après vous programmerez un EXFMT du format de contrôle du
sous-fichier.
Cet EXFMT vous affichera comme d'habitude le format de contrôle (c'est-à-dire
l'en-tête d'écran), et le sous-fichier lui-même.
Mais attention, cela ne peut fonctionner que si le sous-fichier est déclaré en

OVERLAY, c'est-à-dire en recouvrement. Sinon, l'EXFMT va effacer l'image
écran produite par le WRITE précédent.
En règle générale, même en dehors des sous-fichiers, l'affichage d'un écran par un
WRITE ou un EXFMT efface totalement l'image-écran précédente, quelle qu'elle
soit.
Sauf si le format envoyé par le WRITE ou l'EXFMT contient la fonction
OVERLAY dans les SDD.
Pour un sous-fichier, la fonction OVERLAY est à écrire au niveau du format de

contrôle.

8.8. Sous-fichier de saisie
Encore un autre cas d'utilisation d'un sous-fichier : vous voulez permettre à

l'utilisateur de saisir une facture. Les données générales de l'en-tête de la facture
peuvent être :
- le numéro de client;
- le numéro de facture;
- la date de la facture.
Elles seront à afficher en haut de l'écran dans le format de contrôle. Des lignes
vierges de facture devront s'afficher ensuite afin de permettre à l'utilisateur de
saisir des données comme :
- le code article;
- la quantité facturée.
Supposons que vous décidiez d'afficher 15 lignes de facture. Vous n'allez tout de
même pas limiter les factures à 15 articles ! Alors, vous allez bien sûr utiliser un
sous-fichier de saisie. C'est un sous-fichier normal dans lequel les zones code
article et quantité facturée seront en entrée-sortie (type B = both)
Pour le premier affichage de l'écran de saisie, vous aurez créé les 15 premiers
enregistrements dans le sous-fichier, avec les codes articles à blanc, et les
quantités à zéro.
Lorsque l'utilisateur tape sur ROLLUP, vous lui créerez gentiment 15 autres
enregistrements vides, qu'il remplira lui-même. Puis il peut retaper ROLLUP, et
ainsi de suite.
Et quand il validera sa facture par la touche Entrée, vous relirez les

enregistrements du sous-fichier qu'il aura rempli, afin de les traiter, en créant par
exemple des enregistrements dans un fichier facture.
Ne pas oublier de lui effacer tous les enregistrements du sous-fichier par

SFLCLR, pour qu'il puisse saisir une autre facture.

9. Les Tableaux
9.1. De l'utilité des tableaux

Il arrive parfois que l'on ait besoin de zones mémoire que je qualifierai de
répétitives. Par exemple, on calcule dans un programme le montant des ventes de
chacun des mois de l'année. On est donc amené à déclarer et à utiliser des zones
mémoire que l'on pourra appeler de la façon suivante :
VENTE01
VENTE02
VENTE03
VENTE04
VENTE05
VENTE06
VENTE07
VENTE08
VENTE09
VENTE10
VENTE11
VENTE12
Si l'on veut calculer les ventes de chaque département français, on aura presque
une centaine de zones à gérer. Pour éviter la lourdeur de gestion d'autant de zones
mémoire, on dispose en GAP de deux techniques : celle des tableaux et celle des
tables.
Nous n'étudierons ici que les tableaux, puisque les tables présentent quelques
restrictions par rapport aux tableaux et ont de ce fait moins d'intérêt.
Un tableau étant un système de mémorisation d'information, il nous faut étudier

les trois phases de programmation d'un tableau :
- la déclaration du tableau;
- le remplissage du tableau;
- la recherche d'information dans le tableau.

9.2. La déclaration d'un tableau
Vous devez rédiger une spécification E pour chaque tableau, après les
spécifications F et avant les spécifications C (respect de l'ordre HFELICO).
Voici les indications minimum à saisir dans une spécification E :
- colonne 6 : "E"
- colonnes 27 à 32 : nom du tableau
- colonnes 36 à 39 : nombre d'éléments du tableau, cadré à droite
- colonnes 40 à 42 : longueur d'un d'élément du tableau cadré à droite
- colonne 44 : nombre de décimales d'un élément du tableau,

obligatoire si celui-ci est de type numérique
9.3. Le chargement d'un tableau
Il existe trois façons de remplir un tableau :
- au moment de la compilation du programme, pour des données constantes et

immuables;
- au début de l'exécution du programme, à partir d'un fichier disque;
- pendant l'exécution du programme, pour des données créées par le programme.
9.3.1. Chargement au moment de la compilation du

programme
Les données du tableau seront chargées dans le tableau au moment de la

compilation. Elles seront donc disponibles dans ce tableau dès le début de
l'exécution du programme.

L'exemple typique d'utilisation de ce mode de chargement est le tableau des
libellés de mois, qui est évidement un ensemble de données immuables :
Janvier
Février
Mars
Avril
Mai
Juin
Juillet
Août
Septembre
Octobre
Novembre
Décembre
Pour programmer ce genre de tableaux, il suffit de saisir les données (les libellés
des mois) à la fin du programme source GAP, après la dernière ligne du
programme.
On devra toutefois intercaler une ligne contenant deux astérisques en colonnes 1 et

2 avant les données du tableau.
On peut, si on le souhaite, saisir plusieurs éléments de tableau sur une ligne.
C'est pourquoi, il faut dans tous les cas ajouter dans la spécification E, en plus des
indications minimales décrites plus haut, en colonnes 33 à 35, le nombre
d'éléments de tableau par ligne de données placée en fin de programme.
Les lignes de données en fin de source GAP doivent commencer en colonne 1.
Un élément de donnée ne doit pas être à cheval sur 2 lignes.
Exemple :
Il s'agit d'un programme utilisant un tableau des libellés des mois, et un autre
tableau indiquant le nombre de jours de chaque mois. On y retrouve bien les
spécifications E, puis les spécifications C, et enfin les données du tableau
précédées par deux astérisques :

E LIB 5 12 10
E DUR 12 12 2 0
C
C
C
C
C
.
.
.
C
C
**
Janvier Février Mars Avril Mai
Juin Juillet Août Septembre Octobre
Novembre Décembre
**
312831303130313130313031
9.3.2. Chargement au début de l'exécution du programme
Le chargement est assuré automatiquement par le système en début d'exécution du

programme. Les données sont situées non plus en fin du source du programme,
mais dans un fichier disque. La spécification E doit contenir, en plus des
indications minimales décrites plus haut :
- le nom du fichier disque en colonnes 11 à 18;
- le nom du fichier de sauvegarde en colonnes 19 à 26, uniquement dans le cas où

le tableau est modifié par le programme et que l'on veuille le sauvegarder
automatiquement en fin de programme sur un fichier disque (un autre que le
fichier d'origine ou alors le même);
- en colonnes 33 à 35 le nombre d'éléments de tableau que contient chaque

enregistrement du fichier disque utilisé pour le chargement;
- un "P" en 43 dans le cas où les données du fichier sont packées.
Le fichier disque doit être de type séquentiel, et ne doit pas être décrit à l'extérieur
du programme par des SDD.

Sa spécification F doit être codée de la façon suivante :
- nom de fichier en colonnes 7 à 14;
- en colonne 15, "I" si le fichier est en entrée seule, et "C" s'il est en entrée-sortie;
- "T" en colonne 16, comme "tableau";
- "F" en colonne 19, pour indiquer le fichier est décrit dans le programme;
- longueur d'enregistrement (cadrée à droite) en 25 à 27;
- "E" en colonne 39, pour signaler que la description du fichier se trouve, non pas
dans les spécification I, mais dans une spécification E de tableau;
- "DISK" en colonne 40.
9.3.3. Chargement pendant l'exécution du programme
Dans ce cas, le chargement du tableau est à la charge du programme GAP et se

déroule donc pendant l'exécution du programme. Les colonnes 11 à 18 et 31 à 33
de la spécification E doivent être blanches, c'est ainsi que le GAP reconnaît les
tableaux chargés à l'exécution. Pour charger un élément de tableau, il suffit de
programmer une instruction d'affectation du genre MOVE ou MOVEL, par
exemple :
MOVEL 'PARIS' DEP,75
ou encore :
MOVE PRIX TAR,AR
Le premier ordre charge la constante alphanumérique "PARIS" dans l'élément

numéro 75 du tableau DEP.

Le deuxième ordre concerne un autre exemple dans lequel on charge la variable
numérique PRIX dans l'élément du tableau TAR, dont le numéro se trouve dans la
variable AR.
Le nombre 75 et la variable AR sont appelés des index de tableau. Un index doit

obligatoirement être numérique, sans décimale.
Un index ne doit jamais être :
- égal à 0;
- inférieur à 0;
- supérieur au nombre d'éléments du tableau.
sinon, il y a déclenchement d'une erreur programme.
On a écrit dans la zone résultat : "DEP,75" et "TAR,AR" , ce qui permet de voir,

au passage, qu'il faut limiter la longueur du nom du tableau ainsi que celle de
l'index de façon à ne pas dépasser les 6 caractères fatidiques de la zone résultat !
Remarque importante : dans les trois modes de chargement de tableau, la

modification des éléments du tableau est tout à fait possible.
Il suffit pour cela d'utiliser des ordres de type MOVE comme dans les 2 exemples
ci-dessus.
9.4. La recherche d'informations dans le tableau
On distingue deux types de recherche dans un tableau :
- recherche d'un élément dans le tableau simplement pour savoir s'il existe (c'est le
cas du contrôle d'une donnée saisie);
- recherche d'une donnée correspondant à un code, par exemple recherche du

libellé du service connaissant le code du service.
9.4.1. Recherche de l'existence d'un élément
Prenons cet exemple, on peut vérifier l'existence d'un code service dans le tableau
des services. Ce code service est une zone alphanumérique de 3 caractères saisie
préalablement sur écran.
On utilisera l'ordre LOKUP (qui vient de l'anglais "to look up"= rechercher) en
plaçant :

- en zone facteur 1 l'argument de recherche : la variable contenant le code service,
dans notre exemple;
- le nom du tableau en zone facteur 2;
- un numéro d'indicateur résultant en colonnes 58 et 59.
Lors de l'exécution de cette instruction, l'ordinateur balaie le tableau du début à la

fin jusqu'à ce qu'il trouve l'argument de recherche. Si l'argument est trouvé dans la
table, l'indicateur résultant (colonnes 58 et 59) est positionné à ON, et à OFF dans
le cas contraire. Il suffira ensuite de conditionner les traitements désirés par cet
indicateur.
Exemple :
CODSER LOKUP TCOD 61

N61 EXSR ERREUR
Explications :
CODSER est le nom de la variable contenant le code service saisi.

TCOD est le nom de la table des codes service.
*IN61 est l'indicateur résultant de la recherche.
Si la recherche n'aboutit pas, on exécutera le sous-programme ERREUR.
9.4.2. Recherche d'une donnée associée à un code
On veut maintenant savoir le nom du service connaissant son code. Cela nécessite
l'utilisation de deux tableaux :
- le tableau des codes services;

- le tableau des noms des services.
Ces deux tableaux seront déclarés (2 cartes E) et chargés l'un après l'autre. Ils
auront bien sûr le même nombre d'éléments et on veillera à ce que l'ordre des
codes service soit le même que l'ordre des noms des services.
Notons toutefois qu'il existe une possibilité (que nous n'utiliserons pas ici) pour
imbriquer les deux tableaux (voir la documentation IBM sur les alternating arrays,
livre "RPG/400 Reference").

Pour rechercher le nom du service dont le code a été saisi, il faut écrire un ordre
LOKUP, comme dans le contrôle d'existence vu précédemment, puis ajouter dans
la zone facteur 2, juste après le nom du tableau, une virgule suivie d'un nom
d'index.
Par exemple :
Z-ADD 1 X 30
CODSER LOKUP TCOD,X 61
N61 EXSR ERREUR
61 MOVEL TNOM,X ZNOM
Les deux tableaux s'appellent :
- TCOD pour les codes service;

- TNOM pour les noms de service.
L'index s'appelle ici : X .

Il doit obligatoirement être remis à 1 avant la recherche, car la recherche s'effectue
dans le tableau à partir de la valeur de cet index.
La recherche par LOKUP s'effectue comme dans le contrôle d'existence vu
précédemment.
Si le code service n'est pas trouvé dans la table, on appelle le sous-programme

ERREUR.
Si le code service est trouvé, on met le nom du service dans la zone ZNOM.

10. Le "débuggage" des
programmes
"Débugger" un programme, c'est trouver la panne d'un programme qui ne fait pas
ce que l'on voudrait. Toutefois, avant d'utiliser le système de "debuggage" de
l'AS/400, il est préférable de vérifier les 4 points suivants :
- Avez-vous utilisé au maximum votre intuition pour vous guider directement

et rapidement vers la cause de l'erreur ?
- Etes-vous sûr que les listings sur lesquels vous cherchez votre erreur
correspondent bien à la dernière version de votre programme et de vos
fichiers de données, d'écran ou d'impression ?
- Votre programme est-il vraiment une traduction fidèle de votre arbre

programmatique ou de votre organigramme ?
- Votre arbre programmatique ou votre organigramme sont-ils justes ?
Une fois tout cela vérifié, il ne vous reste plus qu'à utiliser ce puissant outil qu'est
le mode DEBUG de l'AS/400. Il fonctionne aussi bien en GAP qu'en COBOL.
Vous pouvez l'utiliser de deux façons différentes :
- en utilisant les "points d'arrêt";

- en utilisant la fonction "trace".
10.1. Les points d'arrêt
Vous allez pouvoir demander que votre programme s'arrête momentanément

pendant son exécution, à des endroits précis que vous aurez déclarés à l'avance.
Cela vous permet tout d'abord de savoir si votre programme passe ou ne passe pas
par les numéros d'instructions que vous avez déclarés.
Ensuite, pendant ces arrêts de votre programme, vous pourrez afficher à votre
guise le contenu de n'importe quelle variable mémoire afin de vérifier son
contenu.

De plus, si ce contenu des variables ne vous plaît pas, vous allez pouvoir modifier
directement ce contenu, puis reprendre l'exécution du programme à l'instruction
suivant le point d'arrêt, comme si de rien n'était.
Supposons que votre programme s'appelle PROG1, et que vous vouliez l'arrêter
chaque fois qu'il passe sur les instructions 200 et 500.
Vous taperez les commandes CL suivantes:
STRDBG PROG1
Ce qui signifie : passer le programme PROG1 en mode DEBUG, puis :
ADDBKP 200
ADDBKP 500
Ce qui signifie : ajouter des points d'arrêt aux instructions 200 et 500. Puis tapez:
CALL PROG1
pour appeler normalement votre programme, ce qui implique d'exécuter celui-ci

en interactif et non en batch par SBMJOB, même si c'est un programme de type
batch, ce que l'on vous pardonnera pour une fois !
Pendant l'exécution de votre programme, un écran s'affiche chaque fois que le

programme passe sur un point d'arrêt que vous avez déclaré.Vous pouvez alors
interroger le contenu de la variable MONT ou de la variable NOM, par exemple,
en tapant:
DSPPGMVAR MONT
ou
DSPPGMVAR NOM
Vous pouvez en modifier le contenu en tapant :
CHGPGMVAR MONT 12345

ou
CHGPGMVAR NOM 'Dupont'
Ce qui aura pour effet de mettre le nombre 12345 dans la variable MONT, et la
chaîne de caractères 'Dupont' dans la variable NOM.
Si vous voulez retirer un point d'arrêt que vous auriez déclaré en trop, par exemple
celui de l'instruction 200, tapez :
RMVBKP 200
Quand vous avez trouvé votre erreur, et que vous ne voulez plus être en mode
DEBUG, tapez :

ENDDBG

10.2. La fonction "trace"
Cette deuxième et dernière fonction du mode DEBUG, va vous permettre de
visualiser la liste des numéros d'instructions par lesquelles votre programme est
passé.
Vous devez comme pour les points d'arrêt, passer en mode DEBUG.
STRDBG PROG1
Puis, tapez la commande CL suivante :
ADDTRC
Ce qui signifie : ajouter la fonction trace. Appelez ensuite normalement votre

programme, impérativement en mode interactif :
CALL PROG1
A la fin de l'exécution de votre programme, ou après l'avoir arrêté autoritairement

par l'option 6 de l'appel système s'il boucle (appel système : voir dans le chapitre
"Trucs et astuces"), passez la commande:
DSPTRCDTA
pour visualiser ou imprimer la fameuse trace. Vous aurez ainsi sous les yeux, la
liste des numéros d'instructions par lesquelles est passé votre programme.
Les boucles seront alors aisément repérable, plus difficilement cependant si elles
sont longues.
Désactivez la fonction trace par l'ordre :
RMVTRC
ou arrêtez complètement le mode DEBUG par l'ordre :
ENDDBG
Notez que le nombre de lignes de trace est réglable dans l'un des paramètres de
l'ordre ADDTRC. Accédez à ce paramètre par la touche guide F4.
En conclusion, essayez au moins une fois ce mode DEBUG, car il est absolument
génial !

11. Trucs et astuces
11.1. L'appel système
Voici une possibilité de l'AS/400 qui est particulièrement intéressante. Vous
disposez sur tout terminal de l'AS/400 d'une touche sur laquelle est inscrit
"ATTN" (comme "attention") ou encore "APPEL SYSTEME", souvent écrit en
abrégé. Donc, pour faire un "appel système", il vous faut appuyer sur cette touche
"ATTN" tout en maintenant appuyée la touche de majuscule "SHIFT". Vous
pouvez accéder à l'appel système pratiquement à tout moment, même pendant
l'exécution d'un programme interactif qui boucle (cela arrive !), c'est-à-dire à un
moment où, comme on dit dans le jargon informaticien, vous n'avez plus la main,
car toutes les touches du clavier sont ineffectives.
Que se passe-t-il lorsque l'on appuie sur la touche d'appel système ? Une ligne de
saisie vierge s'affiche instantanément tout en bas de votre écran. Vous pouvez
alors taper simplement sur la touche entrée, ce qui vous affichera un menu avec au
total 9 options numérotées 1, 2, 3, 4, 5, 6, 7, 80, 90. Mais si vous êtes un habitué
de l'appel système, vous prendrez vite l'habitude de taper le numéro d'option
directement sur la ligne de saisie vierge en bas de l'écran, plutôt que de faire
"entrée" pour afficher le menu de l'appel système.
Etudions le rôle de chacune des 9 options.
11.1.1. Option 1 : ouverture ou transfert d'une session

alternée
En choisissant cette option, vous allez mettre en attente la session dans laquelle
vous êtes, et ouvrir une nouvelle session. Concrètement, un nouvel écran
d'ouverture va s'afficher, vous demandant comme d'habitude votre nom de profil,
votre mot de passe, etc.
Vous ouvrez donc une deuxième session, tout à fait indépendante de la première
session. Cette première session reste en attente, jusqu'à ce que vous y reveniez.
Pour revenir à la première session, deux solutions :
1) vous quittez la deuxième session par l'option 90 de son menu principal ou bien
encore par la commande SIGNOFF ; la deuxième session est alors terminée, et
votre terminal réaffiche la première session au point exact où elle était arrêtée.

2) vous refaites un appel système en choisissant à nouveau l'option 1, cela ne vous
ouvre pas une troisième session (2 sessions maximum), mais revient à la première
session , en laissant la deuxième en attente.
Remarquons que si vous utilisez un terminal bi-sessions comme nous l'avons

évoqué au début de ce livre, vous pourrez ouvrir deux sessions qui seront gérées
par le hardware du terminal. Et en plus, dans chacune de ces deux sessions, vous
pouvez ouvrir deux sessions grâce à l'appel système : au total 4 sessions
simultanées !
L'intérêt d'ouvrir 4 sessions en même temps reste à démontrer, mais ouvrir deux
sessions sous des profils utilisateur différents permet de résoudre bien des
problèmes, par exemple de droits d'accès.
11.1.2. Option 2 : arrêt de la commande précédente
Si vous lancez une commande en mode interactif, et que cette commande dure
trop longtemps, cela peut venir de votre programme qui boucle indéfiniment, ou
bien d'un temps de réponse très long mais normal. Essayez par exemple le temps
de réponse de la commande :
DSPLIB *ALL
qui affiche le contenu de toutes les bibliothèques de l'AS/400 !
Si vous êtes dans cette situation, et que vous ne voulez pas attendre la fin de votre
requête, ne coupez pas le courant de votre terminal, ce n'est vraiment pas la bonne
solution. Mais faites un appel système, puis choisissez l'option 2 pour arrêter la
demande en cours. Vous reviendrez alors à la situation précédant le lancement de
la commande qui vous a rendu impatient.
11.1.3. Option 3 : informations sur le travail en cours
Par cette option, vous lancez automatiquement la commande :
DSPJOB
Elle affiche toutes les informations concernant le travail en cours, c'est-à-dire

concernant votre session. Par un système de menus, vous pouvez afficher la liste
des programmes appelés, la liste des fichiers verrouillés, l'heure de début de
session, et encore bien d'autres informations.

11.1.4. Option 4 : afficher les messages en attente
Une file d'attente de messages est une sorte de boîte aux lettres. Les files d'attente
de messages sont des objets AS/400, de type MSGQ, c'est-à-dire "message
queue", à prononcer "message kiou" !
Chaque profil utilisateur a sa propre file d'attente de messages. De plus, chaque

poste de travail a aussi sa propre file d'attente de messages. Par conséquent, si
vous utilisez un terminal AS/400, vous avez forcément deux boîtes aux lettres :
celle de votre profil, et celle de votre terminal.
Mais d'où viennent les messages ? Il peut arriver que l'OS/400 vous envoie un
message signalant tel ou tel problème. Il peut aussi arriver que d'autres utilisateurs
vous envoient des messages, ou même que des programmes vous envoient des
messages. Selon le cas, ce sera l'une ou l'autre des files d'attente qui sera utilisée.
Pour consulter vos 2 boîtes aux lettres, faites simplement un appel système avec
l'option 4. Cela équivaut à la commande :
DSPMSG MSGQ(*WRKUSR)
11.1.5. Option 5 : envoi d'un message
L'option 5 permet d'envoyer un message dans une file d'attente. Vous pourrez
taper le texte du message ainsi que le nom du destinataire. Cela correspond à la
commande CL:
SNDMSG
11.1.6. Option 6 : afficher les messages de l'opérateur

système
Tous les messages de gestion de l'imprimante système, ainsi que les messages
concernant le chargement des supports magnétiques de sauvegardes (disquettes,
cassettes, bandes), mais aussi les messages concernant le réseau des terminaux
arrivent en général dans la file d'attente de l'opérateur système. L'opérateur du
système, souvent appelé pupitreur, et qu'IBM a choisi de nommer très

poétiquement QSYSOPR, a, comme tout profil utilisateur, sa file propre d'attente
de messages.
Lorsque l'on a des problèmes sur une imprimante, ou que l'on fait des
sauvegardes, ou que des incidents proviennent sur le réseau, il est très commode
de faire un appel système avec l'option 6, pour voir et éventuellement répondre
aux messages que l'OS/400 aurait délicatement déposé dans la file d'attente de
l'opérateur système.
Cela correspond à la commande :
DSPMSG MSGQ(QSYSOPR)
11.1.7. Option 7 : afficher des informations à propos du

terminal
Cette option permet d'afficher des informations à propos de ce qui se passe sur
votre terminal. En particulier, si deux sessions sont ouvertes en même temps, vous
saurez sur quels profils utilisateur elles sont ouvertes. C'est souvent très utile, car
lorsque l'on a plusieurs sessions en cours sur le même terminal, il arrive souvent
que l'on ne sache plus dans laquelle on se trouve.
L'option 7 est équivalente à la commande CL :
DSPWSUSR
11.1.8. Option 80 : déconnexion

Si vous devez interrompre momentanément votre travail sur le terminal,
choisissez l'option 80. Elle déconnecte la session en cours, ou les deux sessions si
une session alternée est ouverte. Mais à la différence de la commande SIGNOFF,
lorsque vous rouvrez votre session, vous la retrouvez exactement dans le même
état que lorsque vous l'avez quitté. C'est-à-dire que le premier écran qui s'affiche
n'est pas l'écran habituel d'ouverture, mais l'écran sur lequel vous étiez lorsque
vous avez fait la déconnexion.
L'option 80 est l'équivalent de la commande :
DSCJOB
11.1.9. Option 90 : fin de session

Cela termine la session, exactement comme le ferait la commande CL :
SIGNOFF
11.2. Modifier sa file d'attente de messages
Si vous souhaitez être instantanément informé du fait que des messages arrivent
dans votre file d'attente de messages, tout comme certaines personnes demandent
au facteur de sonner quand il met une lettre dans la boîte, modifiez le mode de
délivrance des messages de votre file d'attente.
Si votre nom de profil est GASTON, tapez :
CHGMSGQ MSGQ(GASTON) DLVRY(*BREAK)
soit en clair : "change message queue, delivery mode = break", et en français :

"modifier la file d'attente de message pour que le mode de délivrance des
messages soit en interruption".
11.3. Imprimer son nom sur les listings
Il peut être intéressant d'imprimer vos nom et prénom en bas de toutes les pages
sorties sur imprimante. Cela permet de "dispatcher" aisément les divers listings de
compilation et autres qui sortent en permanence de l'imprimante.
Vous vous appelez maintenant Jeanne DULAC, et votre bibliothèque s'appelle

BIB3. Tapez alors les 3 commandes suivantes :
CRTDUPOBJ OBJ(QDFTJOBD) FROMLIB(QGPL)

OBJTYPE(*JOBD) TOLIB (BIB3)
CHGPRF JOBD(BIB3/QDFTJOBD)
CHGJOBD JOBD(BIB3/QDFTJOBD) PRTTXT('DULAC Jeanne')

INLLIBL(QTEMP QGPL BIB3)
La première commande CRTDUPOBJ signifie "Create Duplicate Object", c'est-à-

dire "Créer un objet dupliqué". Elle crée dans la bibliothèque BIB3, un double de
l'objet QDFTJOBD de la bibliothèque QGPL. L'objet QDFTJOBD est une

description de job par défaut. Une description de job, ou JOBD, définit de
nombreuses caractéristiques d'environnement d'un job.
La deuxième commande CHGPRF est une commande que nous connaissons déjà.
Elle permet de modifier les caractéristiques d'un profil utilisateur. Ici, on modifie
la spécification de l'endroit où chercher la description de job par défaut. On
demande donc à utiliser la description de job QDFTJOBD stockée dans la
bibliothèque BIB3, et non plus dans la bibliothèque QGPL, comme
précédemment.
Enfin, la troisième commande CHGJOBD sert à introduire comme caractéristique

de la JOBD le texte à imprimer en bas de chaque page. C'est le paramètre
PRTTXT. De plus cette commande modifie le paramètre INLLIBL, qui est la liste
des bibliothèques servant à la recherche des objets. C'est l'équivalent du PATH
pour les connaisseurs du MSDOS.
11.4. Contrôle des zones de saisie
Nous avons vu dans le chapitre concernant les fichiers-écran, qu'il est possible de
faire exécuter par le système d'exploitation des contrôles sur les champs saisis par
l'utilisateur. Cela vous fera faire des économies substantielles de programmation.
Ainsi, nous avons vu les fonctions de contrôle automatique COMP, VALUES, et
RANGE.
Mais, hélas, le contrôle de validité d'un champ ne sera effectué que si l'utilisateur a
saisi ou modifié des caractères dans le champ.
Prenons par exemple, un champ baptisé MOIS dont les SDD spécifient le contrôle
de validité suivant :
RANGE (1 12)
Ce qui signifie : contrôler que le champ MOIS a une valeur comprise entre 1 et
12. Si l'utilisateur y tape le nombre 13, le contrôle sera effectué, et une erreur sera
déclenchée, avec affichage d'un message et blocage du clavier.
Là où il y a problème, c'est qu'en revanche, si l'utilisateur saute le champ MOIS en
le laissant blanc, et passe au champ suivant, alors il n'y aura pas de contrôle du
champ MOIS. La valeur blanche de ce champ passera au travers des mailles du
système. Ce qui est généralement très gênant.
Pourquoi cela fonctionne-t-il ainsi ? Eh bien, à chaque champ en entrée ou en

entrée-sortie d'un écran est associé un bit géré par le système d'exploitation. Ce bit
passe automatiquement à ON dès que l'utilisateur modifie au clavier le contenu de
ce champ. Et tant que le champ n'est pas modifié, le bit reste à OFF. Ce bit est
appelé le MDT, en anglais "Modified Data Tag", c'est-à-dire "indicateur de
modification de donnée".

Revenons à notre problème de contrôle du champ MOIS, nous comprenons mieux
que le contrôle n'est effectué que si le MDT est à ON. Pour remédier à ce
problème, IBM a prévu une fonction à écrire dans les SDD, c'est la fonction :
DSPATR(MDT)
Elle force tout simplement le MDT à ON, que l'utilisateur ait ou non modifié le
champ. Ainsi les contrôles demandés dans les SDD seront effectués
systématiquement dans tous les cas.
11.5. Verrouillage d'enregistrements
Un système de verrouillage d'enregistrements dans les fichiers de données est

prévu sur l'AS/400. Quel est son but ?
Supposons un système informatisé de réservation de place d'avion. On dispose

d'un fichier des places d'avion, qui contient un enregistrement par place. Chaque
place peut être soit disponible, soit réservée, selon le contenu d'un champ qui peut
être égal à "D" ou à "R".
L'utilisateur U1 d'un terminal interroge dans ce fichier la place X, voit à l'écran

qu'elle est disponible, discute quelques instants avec son client, puis valide la
réservation.
Malheureusement, pendant la très courte discussion entre l'utilisateur U1 et son
client, un autre utilisateur U2 interroge la même place X, voit qu'elle est
disponible, et... la réserve sans problème.
Vous imaginez la suite, à l'heure du départ de l'avion !
Pour éviter d'aussi fâcheuses situations, IBM a mis en place dans l'OS/400, un
système de verrouillage d'enregistrements qui fonctionne suivant la règle ci-
dessous.
Soit deux programmes P1 et P2 qui utilisent tous deux le fichier F en

mise à jour ("U" en colonne 15 de la spécification F), alors tout
enregistrement de F lu par P1 sera inaccessible par P2.
L'enregistrement bloqué ne sera libéré que lorsque P1 aura effectué
l'une des actions suivantes :
- réécriture de l'enregistrement par un ordre UPDAT

- lecture d'un autre enregistrement par un ordre READ, cet autre
enregistrement devenant verrouillé à son tour
- effacement de l'enregistrement par un ordre DELET
- création d'un nouvel enregistrement par un ordre WRITE
- fermeture du fichier automatique à la fin du programme P1

Pendant le laps de temps où l'enregistrement de F est verrouillé par P1, le
programme P2 ne peut pas faire d'opération sur cet enregistrement. Si comme
dans le programme de réservation de places d'avion, le programme P2 veut
accéder par un CHAIN à un enregistrement verrouillé, alors P2 se met en attente
pendant une durée d'environ 2 minutes (réglable) pour le cas où P1 libérerait
rapidement l'enregistrement.
Si, après ce laps de temps, l'enregistrement reste encore verrouillé par P1,
l'indicateur d'erreur des colonnes 56 et 57 de l'ordre CHAIN de P2 sera positionné
à '1'. Votre programme pourra alors intercepter et traiter la situation comme il
convient, c'est-à-dire ici en affichant un message demandant à l'utilisateur de
refaire une tentative d'interrogation quelque temps plus tard.
Finalement, le système OS/400 vous informe du conflit d'accès grâce à l'indicateur

des colonnes 56 et 57, mais c'est à vous d'en gérer les conséquences dans votre
programme.
Attention à éviter les blocages inextricables que sont les "dead-locks" encore
baptisés "étreintes fatales". Le "dead-lock" se produit lorsqu'un utilisateur A veut
accéder à un enregistrement verrouillé par l'utilisateur B, alors que cet utilisateur
B cherche à accéder à un enregistrement verrouillé par l'utilisateur A.
Beau problème de logique que je soumets à votre sagacité !

Annexes

Annexe 1 : Exemple de programme GAP

Annexe 2 : Spécifications GAP vierges

Annexe 3 : Exemples de calculs en GAP
Le contenu des rubriques avant les opérations :
A = 5.00
B = 2
C = -5
D = 4
E = 1,2
F = 0
G = 10
H = 5.72
I = 42
J = 7
K = 32
L = 36
R = 0
Les opérations et leurs résultats :
ADD 1 A Résultat : A= 6.00

B ADD C R Résultat : R= -3
Z-ADD -1 B Résultat : B= 1
SUB 1 C Résultat : C= -6
E SUB D R Résultat : R= -2.8
Z-SUB 5 F Résultat : F= -5
G MULT H R Résultat : R= 57.2
I DIV J R Résultat : R= 6
DIV 3 K Résultat : K= 10
MVR R Résultat : R= 2
SQRT L R Résultat : R= 6

Annexe 4 : Normalisation des indicateurs
Nous préconisons ici de normaliser le choix des numéros d'indicateurs, de façon à

retrouver dans tous vos programmes, et peut-être aussi dans ceux de vos
collègues, une sorte de langage commun, condition indispensable pour rendre
possible la maintenance ultérieure des logiciels.
Le numéro d'indicateur Son utilisation
01 Touche fonction F1
. .
. .
31 Touche ROLLUP ou PAGE UP

32 Touche ROLL DOWN ou PAGE DOWN
41 Indicateur de message d'erreur

42 Indicateur de message d'erreur
. .
. .
51 Ecran 1 actif
52 Ecran 2 actif
53 Ecran 3 actif
. .
. .
61 Indicateur divers
62 Indicateur divers
. .
. .
81 Clé invalide sur un fichier

82 Clé invalide sur un fichier
. .
. .
91 Fin de fichier
92 Fin de fichier
. .
. .

Annexe 5 : Corrigé des exercices

CORRIGE DE L'EXERCICE 1
Z-ADD 1000 COMPT 40

COMPT DOWLT 2000
COMPT ADD 3 COMPT
END

MONT1 IFLE 10000

MONT1 ADD 100 MONT1
ELSE
MONT1 MULT 0.95 MONT1
END

MONT1 IFLE 10000

MONT1 ADD 100 MONT1
ELSE
MONT1 IFGT 50000
MONT1 MULT 0.95 MONT1
END
END

Z-ADD 0 PRIME 72
N05 ADD 1000 PRIME
05 ADD 500 PRIME
06 10 ADD 400 PRIME
06 N07 11 ADD 2600 PRIME

Z-ADD 0 PRIME 72
*IN05 IFEQ '0'
PRIME ADD 1000 PRIME
ELSE
PRIME ADD 500 PRIME
END
*IN06 IFEQ '1'
*IN10 IFEQ '1'
PRIME ADD 400 PRIME
END
END
*IN06 IFEQ '1'
*IN07 IFNE '1'
*IN11 IFEQ '1'
PRIME ADD 2600 PRIME
END
END
END

Version en programmation structurée normale :
EXSR P10
*IN91 DOWEQ '0'
EXSR REP1
END
EXSR P90
REP1 BEGSR
EXSR P20
PSEX IFEQ 'F'
EXSR P30
ELSE
EXSR P40
END
EXSR P50
ENDSR
P10 BEGSR
Z-ADD 0 NBF 60
Z-ADD 0 TOTALH 92
READ PERS 91
ENDSR
P20 BEGSR
ENDSR
P30 BEGSR
NBF ADD 1 NBF
ENDSR
P40 BEGSR
TOTALH ADD PSAL TOTALH
ENDSR
P50 BEGSR
READ PERS 91
ENDSR
P90 BEGSR
ENDSR

Version en programmation structurée pure :
Z-ADD 0 NBF 60
Z-ADD 0 TOTALH 92
READ PERS 91
*IN91 DOWEQ '0'
PSEX IFEQ 'F'
NBF ADD 1 NBF
ELSE
TOTAL ADD PSAL TOTAL
END
READ PERS 91
END

Z-ADD 0 TOTAL 92
'B5' CHAIN SERV 81
*IN81 IFEQ '0'
MOVEL SNOM ENOS
WRIT ENTET
READ PERS 91
*IN91 DOWEQ '0'
PSER IFEQ 'B5'
MOVEL PMAT EMAT
MOVEL PNOM ENOM
MOVE PSAL ESAL
WRITE LIGNE
TOTAL ADD PSAL TOTAL
END
READ PERS 91
END
MOVE TOTAL ETOT
WRITE FIN
END

Annexe 6 : Programme interactif GAP
Voici la structure d'un programme GAP interactif, selon la méthode de

programmation structurée interactive dite "méthode FAULLE" du nom de son
auteur. Bien sûr, toute autre méthode peut convenir :

SETON 51
*INLR DOWNE '1'
51 EXFMT ECRAN1
52 EXFMT ECRAN2
51 03 CAS ACTION1
51 CAS ACTION2
52 03 CAS ACTION3
END
END
ACTION1 BEGSR
EXSR RAZ
...
...
SETON LR
ENDSR
BEGSR
ACTION2 EXSR
... RAZ
...
SETON 52
ENDSR
BEGSR
EXSR
ACTION3 ...
... RAZ
SETON 51
ENDSR
BEGSR
SETOF 41
SETOF 42
RAZ SETOF 51
SETOF 52
ENDSR
Quelques mots pour expliquer la méthode FAULLE.

Un programme est découpé en actions, qui sont en fait des sous-programmes
internes. A chaque couple "image écran affichée + touche de fonction
appuyée" va correspondre une action (et une seule). Par exemple, l'action
ACTION3 s'exécutera uniquement si l'image-écran ECRAN2 est affichée sur le
terminal et si l'utilisateur a appuyé sur la touche fonction F3.
Dans notre exemple, le programme est découpé en 3 actions :

- ACTION1 lorsque ECRAN1 est affiché et que l'utilisateur appuie sur la touche
F3
- ACTION2 lorsque ECRAN1 est affiché et que l'utilisateur n'appuie pas sur la
touche F3, c'est-à-dire s'il appuie sur la touche ENTREE
- ACTION3 lorsque ECRAN2 est affiché et que l'utilisateur appuie sur la touche
F3
Tout programme "Faulle" est constitué essentiellement d'une structure répétitive

(DOWNE) à l'intérieur de laquelle on trouve une alternative multiple programmée
par des ordres CAS. A chaque CAS correspond une action.
Dans chaque action, on commence par remettre tous les indicateurs à 0. Les lignes
contenant trois petits points sont à remplacer par les instructions nécessaires au
travail demandé.
Voici le rôle des indicateurs utilisés dans ce programme :
03 touche fonction F3
41 indicateur d'erreur d'accès à un fichier par exemple
42 idem
51 écran ECRAN1 actif
52 écran ECRAN2 actif
LR fin de programme

Index
A
ADD, 51
ADDBKP, 170
ADDMSGD, 133
ADDTRC, 171
appel système, 172
ATTN, 172
AUA, 35
B
BARCODE, 85
bases de données, 18
BASIC, 43
BEGSR, 69
bibliothèques, 24;40
C
CA, 123
CALL, 32;42;71;170;171
CF, 123
CHAIN, 75;179
CHECK, 128
CHGJOBD, 176
CHGMSGQ, 176
CHGPGMVAR, 170
CHGPRF, 33;34;36;38;176
CHRSIZ, 86
CL, 18
CLEAR, 136
COBOL 85, 43
COLHDG, 100;102
COLOR, 126
COMP, 102;177
CONCAT, 112
CPI, 86
CRTDUPOBJ, 176
CRTLF, 108
CRTLIB, 38
CRTMSGF, 133
CRTPF, 99
CRTPRTF, 32;92
CRTRPGPGM, 40
CRTSRCPF, 39;91
CSRLOC, 134
D
DATE, 86;135

débuggage, 169
déclaration automatique, 54
DELET, 178
DESCEND, 103
DFNCHR, 87
DFU, 20
DIV, 52
DOWxx, 58
DSCJOB, 175
DSPATR, 125;178
DSPJOB, 173
DSPJOBLOG, 41
DSPLIB, 39;173
DSPLIBL, 38
DSPMSG, 174;175
DSPPGMVAR, 170
DSPSYSVAL, 32;36
DSPTRCDTA, 171
DSPWSUSR, 175
E
EDTCDE, 87;104
EDTWRD, 87;104
EDU, 22
ENDDBG, 170;171
ENDSR, 69
ERRMSG, 132
ERRMSGID, 132
Ethernet, 14
EXFMT, 137;150
EXSR, 69
F
fichiers d'impression, 41
FIFO, 104
files d'attente, 25
FORTRAN, 43
G
GAP, 43
gros système, 5;7;9;10
H
HIGHLIGHT, 88
HOME, 136
I
IBM36, 43
IBM38, 43
IDDU, 20
IFxx, 62
imprimante, 13
indicateur, 44;57

INLLIBL, 177
J
JFILE, 118
JFLD, 118
JOBQ, 29
JOIN, 118
L
Langage C, 43
langage CL, 32
LIFO, 104
LOKUP, 166
M
MDT, 178
membre, 26;40
mémoire, 10
menus, 32
message, 174
micro-ordinateur, 5
mini-ordinateur, 5
moniteur de télétraitement, 19
mot de passe, 31
MOVE, 52
MOVEL, 53
MSDOS, 16
MULT, 52
multi-tâches, 17;29
MVR, 52
N
norme SAA, 35
O
objets, 24;40
OFFICE 400, 23
officier de sécurité, 31
OUTQ, 29;30;41
OVERLAY, 159
P
PAGNBR, 88
paramètre, 32
PARM, 71
PASCAL, 43
PCS, 21
PDM, 19
PFILE, 112
PL/I, 43
points d'arrêt, 169
PRINT, 135;136
processeur, 10
profil utilisateur, 25;31

programmation en cycle, 44
programmation hors cycle, 45
PRTTXT, 177
Q
QDDSSRC, 91
QDFTJOBD, 176
QSYSOPR, 175
QUERY, 20
R
RANGE, 100;104;109;177
READ, 56;136;178
READC, 155
REFACCPTH, 112
réseau de terminaux, 13
réseau local, 14
RETRN, 71
RLU, 20
RM/COBOL, 43
RMVBKP, 170
RMVTRC, 171
ROLLDOWN, 136
ROLLUP, 136;150
S
SAVLIB, 32
SBMJOB, 42;170
SDA, 19
SDD d'impression, 80
SDD de fichiers de données, 93
session, 31
session alternée, 172
SETOFF, 66
SETON, 66
SETON LR, 78
SEU, 19
SFILE, 152
SFL, 147
SFLCLR, 149;160
SFLCTL, 148
SFLDSP, 149
SFLDSPCTL, 149
SFLEND, 151
SFLINZ, 151
SFLLIN, 151
SFLPAG, 148
SFLRCDNBR, 150
SFLROLVAL, 151
SFLSIZ, 148
SGBD relationnel, 18

SIGNOFF, 38;172;176
SKIPA, 88
SKIPB, 89
SNDMSG, 174
sous-fichiers, 138
sous-programme, 68;71
SPACEA, 89
SPACEB, 90
spécifications, 45
SPOOL, 30
SQRT, 52
SST, 113
STRDBG, 170;171
STRPDM, 40;91
STRSEU, 40;91
SUB, 52
switch, 14
T
Tableaux, 161
terminator, 14
terminaux, 12
TEXT, 105
TIME, 90;135
Token Ring, 14
twinax, 13
U
UNDERLINE, 90
UNIQUE, 101;105
UNIX, 16
UPDAT, 155;158;178
V
VALUES, 105;109;177
W
WRITE, 72;73;136;178
WRITER, 30
WRKMSGD, 133
WRKSBMJOB, 41
WRKSPLF, 32;41
Z
Z-ADD, 51
Z-SUB, 52

As400 Tutoriel CL PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

As400 Tutoriel CL PDF

Hochgeladen von

Copyright:

Verfügbare Formate

AS/400

Casablanca Maroc Email : oits.maroc@gmail.com Tel: 061425929

Janvier2012 v12 -Cap.- AS/400 Page 1

Le hardware de l'AS/400 ....................................................................................................... 5

Janvier2012 v12 -Cap.- AS/400 Page 2

Janvier2012 v12 -Cap.- AS/400 Page 3

Ce livre va vous servir de guide sur le chemin des "moyens-systèmes" IBM

Alors, d'où partons-nous, c'est-à-dire où en êtes-vous en informatique ?

- connaître le principe général de fonctionnement des ordinateurs;

- savoir à quoi sert un système d'exploitation;

- savoir ce qu'est un fichier, un enregistrement, une rubrique, un octet, un bit;

- savoir écrire un petit programme, peu importe le langage.

Janvier2012 v12 -Cap.- AS/400 Page 4

- connaître l'architecture hardware de l'AS/400;

- connaître le principe de fonctionnement du système d'exploitation de l'AS/400;

- savoir rédiger un programme GAP simple;

- savoir saisir, compiler, exécuter un programme;

- savoir créer des fichiers.

En résumé, ce livre doit permettre à une personne déjà initiée à la

Le point de départ et le point d'arrivée de notre périple vous conviennent-ils ?

Vous êtes toujours là ?

Vous avez répondu "oui" ? Alors on commence.

Janvier2012 v12 -Cap.- AS/400 Page 5

1.1. L'AS/400 dans la gamme IBM

Situons d'abord l'AS/400 parmi ses confrères.

- les moyens systèmes, encore appelés mini-ordinateurs,

- les gros systèmes, appelés aussi "main-frames".

1.1.1. Les micro-ordinateurs IBM

Les premiers constructeurs de micro-ordinateurs s'appellent APPLE,

Aujourd'hui, pratiquement toute la micro-informatique professionnelle est

Janvier2012 v12 -Cap.- AS/400 Page 6

Puis il devient capable de traiter 16 bits, c'est le processeur INTEL 80286.

La concurrence devenant rude, et le PC quelque peu dépassé, IBM sort quelques

1.1.2. Les moyens systèmes IBM

Janvier2012 v12 -Cap.- AS/400 Page 7

La différence de puissance entre IBM 36 et IBM 38 est telle que le 36 convient

1.1.3. Les gros systèmes IBM

Janvier2012 v12 -Cap.- AS/400 Page 8

Encore un autre modèle d'ordinateur IBM, c'est l'intermédiaire entre un moyen et

Sorti récemment chez IBM, il se situe plutôt dans la gamme mini. Il a la

1.2. Carte d'identité de l'AS/400

Date de naissance : 21 JUIN 1988

Lieu de naissance : USA

Complétons cette carte d'identité par la description des différents modèles

Janvier2012 v12 -Cap.- AS/400 Page 9

1.2.2. Le boîtier 9404

Légèrement plus volumineux, mais tenant toujours sous un bureau, il abrite le

En effet, 20 terminaux utilisés toute la journée pour de la saisie intensive

1.2.3. Le boîtier 9406

Janvier2012 v12 -Cap.- AS/400 Page 10

Janvier2012 v12 -Cap.- AS/400 Page 11

Tous les ordinateurs ont la même architecture, de la plus petite calculatrice

- des organes de stockage;

- des organes d'entrée et de sortie.

Reprenons chacun de ces organes :

1.3.1. L'organe de traitement

L'organe de traitement s'appelle comme d'habitude le processeur. C'est un

1.3.2. Les organes de stockage

Le (ou les) disque(s) magnétique(s) fixe(s)

C'est l'équivalent des disques durs sur micro-ordinateurs. Différentes capacités

Janvier2012 v12 -Cap.- AS/400 Page 12

Le lecteur de disquettes éventuel

Le lecteur-enregistreur de bandes magnétiques en cartouches