Tutoriel complet de Cobol

                           CHAPITRE 1 : INSTRUCTIONS ET TYPES ELEMENTAIRES

1Introduction

COBOL est un langage de programmation de troisième génération créé en 1959. Son nom est un acronyme (COmmon Business Oriented Language) qui révèle sa vocation originelle : être un langage commun pour la programmation d'applications de gestion. Le standard COBOL 2003 supporte en particulier la programmation orientée objet et d'autres traits des langages de programmation modernes.

Le langage COBOL était de loin le langage le plus employé dans les années 60 à 80, et reste toujours en utilisation dans des entreprises majeures, notamment dans les institutions financières qui disposent d'une vaste bibliothèque d'applications COBOL.

En 2005, le Gartner Group estimait que 75% des données du monde des affaires étaient traitées par des programmes en COBOL et que 15% des nouveaux programmes développés le seront dans ce langage.

2Structure générale d’un programme Cobol

Un programme COBOL comporte quatre divisions qui contiennent des sections formées de paragraphes. Chaque paragraphe commence par une étiquette, et contient des phrases terminées par des points. Chaque phrase est composée d'instructions (ou de déclarations) commençant par un verbe et comportant éventuellement des clauses optionnelles.

Les entêtes sont optionnelles mais seront de plus en plus utiles pour la lisibilité du programme par l’utilisateur et finalement par le compilateur. 

L’environnement de travail que nous utiliserons est Net Express de MicroFocus.

Documentation en ligne sur :

program-id. nom-du-programme.                   *>partie en-tête du programme

-  - - - - - - -

[data division.]                                                 *>partie des déclarations

[working-storage section.]                              *>variables locales

-  - - - - - -

screen section.                                                 *>plages et champs d'écran

-  - - - - - -

[procedure division.]                                       *>partie des instructions

-  - - - - - - -

-  - - - - - - -

end program nom-du-programme. *>fin du programme

3Exemple détaillé n°1

3.1Le programme

Enoncé du problème: Une automobile a parcouru une certaine distance en un certain temps et  a consommé une certaine quantité de litres d’essence. 

On recherche sa vitesse moyenne et sa consommation au kilomètre pour ce trajet.

Solution :

Les données : 

           distance en km : nbkm           durée en heures et centièmes : nbhc

                       quantité d’essence consommée en litres et centièmes : nblc

Les résultats recherchés :

 vitesse moyenne en km et centième par heure : vm  consommation au km en litres et centièmes : consokm La démarche : 

Lire les données : nbkm, nbhc, nblc

Calculer vm : vm=nbkm/nbhc

Calculer consokm : consokm= nblc/nbkm Afficher les résultats : vm, consokm

3.2Les commentaires du programme

Ce programme comporte 3 parties :

      Une partie contenant la déclaration des variables. Il s’agit ici de 5 numériques :

 pic 999v99 correspond à un numérique avec 3 chiffres avant le séparateur décimal et 2 après.

 Une partie « screen section » : dans laquelle on décrit précisément où et comment seront saisies/affichées les données.

on peut aussi écrire *> début n’importe ou sur la ligne

display a-plg-titre permet d’afficher la plage telle qu’elle a été définie en screen section

compute vm = nbkm / nbhc

instruction permettantde réaliser le calcul de l’expression nbkm / nbhc et d’affecter le résultat à la variable vm.

goback instruction permet de retourner au programme appelant (ici le programme principal)

En résumé, pour écrire le programme en cobol, il faut :

4Partie des déclarations 

 Est une suite de lignes de déclarations.

4.1Section des constantes et des variables (working-storage section)

4.1.1Déclaration d'une constante

Le ‘78’ est situé en colonne 8 et 9.

4.1.2Déclaration d'une variable

            dans ce cas la mémorisation est implicite : un caractère par octet (display)           id-type est le nom d'un type déclaré en amont.

‘Valeur’ est la valeur initiale.

Le descripteur de type (descr-type) est une combinaison permise de symboles, pour décrire : 

a)des types numériques purs

‘9’                    représente un chiffre décimal de 0 à 9 : mémorisé dans un octet

‘V’ ou ‘v’ symbolise une marque décimale virtuelle pour les calculs : ne prend pas de place mémoire supplémentaire

‘S’ ou ‘s’          représente un signe pour les calculs : pas d’occupation mémoire supplémentaire

Exemple : 

1 nbkm             pic 999v99.

1 num pic9(3)v9(2).

b)    des types  alphabétiques

‘A’ ou ‘a’         représente une lettre ou un espace : mémorisé dans un octet

c)  des types alphanumériques

‘X’ ou ‘x’         symbolise un caractère quelconque du jeu de caractères : occupe un octet

Remarque

Chaque symbole peut être suivi d'un facteur de répétition entre parenthèses.

4.1.3Déclaration d'un type simple

4.1.4Déclaration d'un booléen

 En Cobol un booléen est toujours attaché à une variable. La valeur du booléen est déterminée par le fait, pour la variable associée, de prendre l’une des valeurs citées dans la déclaration du booléen.

              nb-niv [id-var-bool]  clause pic [clause value] .

             88  id-bool       value  liste [] de     const                               [false const] .

constj  thru  constk

Exemple :

1         resultat pic x.

88        juste value ‘1’ false ‘0’.

La variable résultat est un caractère qui prend la valeur ‘0’ ou ‘1’

Le booléen juste est attaché à la variable résultat et prend la valeur vrai si résultat contient la valeur ‘1’ et faux sinon.

Exemple : 

1 note_finale  pic  99v99.

88 passable value 10 thru 11.99.

88 assez_bien  value  12 thru 13.99.

88 bien value  14 thru 15.99.

Le booléen passable prend la valeur vrai dès que la variable note_finale prend une valeur dans l’intervalle 10 à 11,99. Dans tous les autres cas, passable prend la valeur faux.

Le booléen bien  prend la valeur vrai dès que la variable note_finale prend une valeur dans l’intervalle 14 à 15,99. Dans tous les autres cas,  bien  prend la valeur faux.

4.2Section des plages et champs d'écran : screen section

Est une suite de déclarations de plages et de champs d'écran.

4.2.1Déclaration d'un champ d'écran constant

avec nb-niv dans [1, 49]

4.2.2Déclaration d'un champ d'écran variable

a) formats des clauses pic étendues

 - Pour un champ d'écran de saisie : 

-  Pour un champ d'écran d'affichage : 

-  Pour un champ d'écran mixte : 

Un descripteur de type édité (descr-ed-type) contient des symboles d'édition pour décrire : 

a)    des types numériques édités

Remarque :

b)    des types alphanumériques édités

‘B’ (ou ‘/’ )            pour l’insertion d’un espace (ou d’un ‘/’) dans la position correspondante

c)  quelques clauses d'écran  auto, background-color, foreground-color, blank-screen, blank-line,  erase eos, erase eol, highlight, lowlight, prompt, required, secure,  reverse-video, underline, . . . .

Remarque :

            Déclarer un nombre signé : s999.99

                                               Afficher un  nombre signé : +999.99 le signe n’apparaît dans tous les cas ou bien -999.99 le signe n’apparaît que lorsque le nombre est négatif.

5La partie des instructions

 Correspond à la procedure division et est une suite d'instructions

5.1Instructions d'affectation

Pour l’affectation numérique, 

Exemple  :

 compute vm = nbkm / nbhc

Pour l’affectation d'un booléen, 

Le positionnement à ‘true’ du booléen entraîne l’affectation automatique, à la variable associée, de la première valeur citée dans la clause ‘value’ de la déclaration du  booléen. Idem pour le positionnement à ‘false’.

5.2Instruction d'initialisation

Cette instruction consiste, sauf indication différente avec l’option ‘replacing’, à initialiser à zéro tous les champs numériques et à blanc les autres. Cette instruction est également valable pour des types complexes tels que les structures et tableaux.

Exemple :

initialize adherent, numero, nom

5.3Instruction de saisie

5.4Instruction d'affichage

5.5Gestion des date et heure courantes

où id-var est une variable de type quelconque.

-option ‘date’

La date du jour, extraite du registre  DATE est affectée à id-var sous le format ‘yymmdd’, ou avec l’année sur 4 chiffres si on ajoute le schéma YYYYMMDD dans l’accept.

-option ‘day’

Il y a affectation à id-var de la date du jour issue du registre DAY, avec l’année sur 2 caractères (ou 4 caractères si on ajoute le schéma YYYYDDD dans l’accept) et le numéro du jour dans l’année sur 3 chiffres.

-option ‘time’

Le registre TIME donne l’heure sous le format ‘hhmmsscc’ c’est à dire en heures, minutes, secondes, centièmes.

Remarque : 

      Les registres sont directement accessibles, sans déclaration.

             En ce qui concerne la date et l’heure courantes ne pas oublier la fonction, sans paramètre,

CURRENT-DATE qui retourne 21 caractères alphanumériques dont o la date en format ‘yyyymmdd’ pour les 8 premiers caractères o l’heure en format  ‘hhmmsscc’ pour les 8 suivants

 La notion de référence modifiée étant aussi applicable à un appel de fonction alphanumérique pour accéder à une partie du résultat on peut, par exemple, écrire :

move function current-date (1 : 4) to date_courante(1 :4) pour affecter les 4 chiffres de l’année à la variable date_courante.

Move function current-date (5 : 2)  to date_courante(5 :2) pour affecter les 2 chiffres du mois à la variable date_courante.

1 date_courante pic 9(8).

ou bien ( voir chapitre suivant, définition de structure).

1 date_courante.

2 annee pic 9(4).

            2 mois pic 99.

            2 jour pic 99.

Exemple de calcul sur des dates : Ajout de 7 jours à la date courante.

program-id. testdate.

working-storage section.

1 dte pic 9(8).

1 val1 pic 9(8).

1 val2 pic 9(8).

screen section.

1 a-val1.

2 line 6 col 10  pic 9(8) from dte.

1 a-val2.

2 line 8 col 10  pic 9(8) from val2.

procedure division.

move function current-date(1:8) to dte(1:8)               display a-val1               compute val1= function integer-of-date(dte) compute val1 = val1 + 7               compute val2 = function date-of-integer(val1)               display a-val2               end program testdate.

Exécution : 

5.6Instructions d'arrêt d'exécution d'un programme

goback :  Assure l’arrêt de l’exécution du programme avec retour du contrôle au programme appelant, c'est-à-dire dans le cas d’un programme principal retour au système d’exploitation, donc arrêt définitif du programme. stop run :  Arrêt définitif du programme.

6Complément sur l’utilisation de fichiers externes

Il est possible d’utiliser des fichiers externes contenant des parties de code Cobol qui seront recopiées dans le code source du programme avant sa compilation.

Soit l’exemple suivant : 

Recopie des contenus des fichiers externes

Le contenu du fichier  ‘’ est :

1 m-plg-saisie.

2 line 5 col 3 'Saisir un nombre r' & x"82" & 'el : '.            2 s-chp-x pic z(4).99 to x required.

Le contenu du fichier ‘’ est : 

1 a-plg-res.

2 line 8 col 3 'La racine carr' & x"82" & 'e est : '.

2 a-chp-y pic zz.99 from y.

Le contenu du fichier ‘’ est 

display m-plg-saisie

accept    s-chp-x                

7Notion de fonction  

7.1Les fonctions prédéfinies 

Il existe de nombreuses fonctions prédéfinies (voir la documentation) que l’on appelle par l’instruction : 

7.2Les fonctions utilisateur

Seront détaillées dans le chapitre 7.

              CHAPITRE 2 : TYPE STRUCTURE ET INSTRUCTIONS DE CONTROLE

1Exemple détaillé n°2

Soit le programme suivant qui permet la saisie d’information client et construit la référence du client.

   program-id. pg-saisie-client.

2Définition de structure 

 A effectuer en working-storage section.

2.1Déclaration d’une structure

Une structure est une suite de lignes de déclaration des champs qui la constituent. C’est-à-dire de la forme :            

            -

            avec un nombre niveau (nb-niv) dans [1, 49]

 Un arbre est, dans une imbrication de structures, la structure la plus externe. La racine  d'un arbre (structure indépendante) est toujours de niveau 1 .

2.2Déclaration d'un type structure

1 typ-adresse typedef.            //déclaration du type structuré ‘typ-adresse’

2 num   pic 9(4).

            2 rue                 pic x(60).         2 codpostal       pic 9(5).

            2 ville               pic x(50).

Ce qui permet de déclarer ‘adresse’ dans adhérent par exemple : adhérent.

1…….

            2          adresse                       typ-adresse

2.3Déclaration d'un type alternatif

Exemple :

1 oper.

2 codoper pic x.         

          2 refprodoper        pic x(5).        

2 prodacreer.

3 designprodoper pic x(20).          

3 qteprodoper pic 9(4).              

   3 prixprodoper      pic 9(4)v99.                  3 fourprodoper      pic x(20).           

2 prodamodif redefines   prodacreer.            

3 qteprodoper pic 9(4).     

                      3                          pic x(46).    

Il faut que la redéfinition d’un objet apparaisse directement après sa définition. On peut redéfinir plusieurs fois un même objet.

2.3.1Déclaration d'une variable de type alternatif

             nb-niv id-var id-type-alt

2.3.2Déclaration d'une désignation de structure bornée

            decl-struct

           66 id-struct-bornée  renames  id-champ-deb  thru  id-champ-fin .

où id-champ-deb et id-champ-fin sont des champs de la structure déclarée immédiatement audessus.

Exemple :

1 client.

2 nom pic x(30).         

          2 prenom       pic x(30).        

2 adresse.

3 numero  pic 9(3).          

3 rue       pic x (40).              

                      3 code postal   pic x(5).              

                      3 ville      pic x(20).      

66 libelle renames nom thru prenom.   

3Notion de paragraphe

Un paragraphe commence par une étiquette (l’identificateur du paragraphe) placée en colonne 8 et suivie d’un point. Un paragraphe est constitué d’une suite d’instructions et se termine à la rencontre d’une autre étiquette de paragraphe ou par la fin physique du programme.

Le premier paragraphe de la procédure division, le seul dont l’étiquette n’est pas obligatoire, est le paragraphe principal , les autres sont les paragraphes secondaires.

3.1Appel d’un paragraphe

L’appel d’un paragraphe, en un point de la procédure division est équivalent à la recopie de son contenu en ce point. Il est possible d’appeler un enchaînement de paragraphes défini par un paragraphe début et un paragraphe fin, dans le sens de l’ordre d’exécution de ceux-ci.

L’instruction suivante permet l’exécution d’un bloc d’instructions (une instruction composée).

3.2Sortie d’un paragraphe

Le contrôle est transféré à la fin du paragraphe.

4Les instructions de contrôle

Exemple :

if correct then perform mod-accord

else  display plg-message            end-if

                                                            CHAPITRE 3 : LES ITERATIONS  

1Itération portant sur une instruction composée

Les itérations peuvent s’exprimer de différentes manières suivant les situations. 

1.1Itération un nombre de fois connu

La suite d’instruction  est répétée le nombre de fois indiqué par la valeur de l’entier ou de la constante.

1.2Itération avec condition

La suite d’instruction est répétée jusqu’à ce que la condition d’arrêt soit vérifiée. 

Le test de la condition peut s’effectuer soit avant l’itération soit après : test before ou test after.

1.2.1Test avant

                         Figure1 : cas d’une seule variable avec ‘test before’

1.2.2Test après

                         Figure2 : cas d’une seule variable avec ‘test after’

1.2.3Avec 2 variables et test after         début

Figure3 : cas de deux variables avec ‘test after’

1.3Itération avec gestion d'une variable

L’exécution est la suivante : 

(test before)

6  lignes et 5 colonnes

L’exécution est la suivante : 

(test after)

7  lignes et 6 colonnes

Exemple 3 :      perform  until  exit

            _ _ _ _ _

exit perform

            _ _ _ _ _

            end-perform

Sortie d’une itération sans fin.

2Instructions d'itération portant sur un module bloc

Un module bloc est un paragraphe (etiq-par) ou une suite de paragraphes caractérisée par un paragraphe début (etiq-par-deb) et un paragraphe fin (etiq-par-fin) et dont l'exécution commence avec la première instruction de id-par-deb et se termine avec la dernière instruction de id-par-fin.

Une suite de paragraphes peut être placée dans une section, unité de composition au plus haut niveau d'une procédure division.

Une procédure division est soit entièrement composée de sections soit entièrement composée de paragraphes.

On désignera par id-mod un module :          etiq-par

                         etiq-par-deb   thru etiq-par-fin                      etiq-sec

où etiq-sec désignera une section définie comme suit :        etiq-sec section .

            liste []  de paragraphes

2.1Itération d'un module bloc

id-mod est répété le nombre de fois indiqué par la valeur de l’entier ou de la constante.

             perform  id-mod     test before        until     cond-arrêt                                                      after                          exit id-mod est répété jusqu'à ce que la condition d’arrêt soit vérifiée.

           perform id-mod      test     before         

                                                         after                  

                                     varying id-var-1  from  val-1  by  pas-1  until  cond-arrêt-1

              liste [ ] de    after  id-var-j  from  val-j  by  pas-j  until  cond-arrêt-j

2.2Instructions de sortie d'un appel itératif d'un module bloc

Cas où le module bloc est un paragraphe :

                        exit paragraph

Cas où le module bloc est une section

                         exit section

3Exemple détaillé n°3

Le programme suivant permet de calculer la racine carrée d’une suite de nombre. Le calcul s’arrête quand l’utilisateur tape ‘N’ ou ‘n’ à la question ‘Voulez-vous continuer ?’

                                     CHAPITRE 4 : LE TYPE CHAINE DE CARACTERES

Une chaîne de caractères est une séquence de caractères entre quotes  '…' ou entre guillemets "…".

1Partie Déclaration (en working-storage section)

1.1Descripteur de type chaîne de caractères 

) ou

1.2Déclaration d'une constante de type chaîne

            78       id-const-ch       value val-ch .

1.3Déclaration d'une variable simple (variable alphanumérique)

 Le nombre niveau est 1 si la variable est indépendante sinon il traduit la position (2 à 49) de la variable dans la structure d'appartenance.

1.4Déclaration d'une variable de type structure (cas particulier de variable chaîne)

 nb-niv id-var-struct .  _ _ _ _ _ _ _ 

            suite de lignes de déclaration des composants

            _ _ _ _ _ _ _

Remarque importante : Une variable de type structure est toujours de type chaîne de caractères, sa valeur est la concaténation des valeurs des feuilles de la structure. 

1.5Déclaration d'un type chaîne de caractères

2Manipulation de chaîne de caractère

2.1Accès à une sous-chaîne (référence modifiée)

            id-var-ch ( rang-deb : long-ss-chaîne )

l'accès au caractère de rang k s'écrit donc id-var-ch ( k : 1 )

2.2Affectation d'une valeur à une variable de type chaîne de caractères

2.2.1Instruction d'affectation

2.2.2Instruction d'initialisation

2.3Comparaison de chaînes de caractères

Dans la comparaison de deux chaînes de caractères, la longueur physique des chaînes n’intervient pas, seuls les caractères contenus sont examinés. La première inégalité rencontrée, lors de la comparaison deux à deux des caractères de même rang dans les deux chaînes, détermine le résultat de la comparaison

2.4Quelques fonctions prédéfinies sur les chaînes de caractères

2.4.1Fonction retournant la longueur d'une chaîne

donne la valeur de la longueur totale de la chaîne y compris les blancs (telle que définie en pic) ou encore :

2.4.2Fonction retournant le maximum d'une liste de valeurs

2.4.3Fonction retournant le minimum d'une liste de valeurs

2.4.4Fonction qui retourne la valeur numérique que représente la chaîne

Exemple :

Compute lg = fonction numval(‘123’)   retourne la valeur numérique 123.

2.4.5Fonction qui retourne la chaîne avec l'ordre inverse de ses caractères

2.5Instructions spécifiques sur chaînes de caractères

2.5.1Concaténation de chaînes de caractères

Les contenus des chaînes  id-var-ch-j , val-ch-j , pour j=1, 2, . . ., sont concaténés, pour chacun, à hauteur de la sous-chaîne précédant la première occurrence du délimiteur indiqué par id-délim,  val-délim ou dans son entier avec l’option ‘size’.

Le résultat est placé dans la variable chaîne ‘id-var-ch’.

L’option ‘pointer’ permet de connaître la position, dans ‘id-var-ch’ du dernier caractère transféré à la fin de l’exécution de l’instruction ‘string’ ; ne pas oublier de déclarer ‘id-pointeur’ en temps que variable entière.

L’option ‘[not] overflow’ permet de prendre le contrôle s’il [n’] y a [pas] débordement dans la variable id-chaîne, avec suspension de l’affectation et exécution de l’instruction  ‘inst-imper1’ [‘inst-imper2’].

Le pointeur, s'il est utilisé, doit être initialisé avant la première exécution de l'instruction 'string' qui le gère ensuite automatiquement. La partie de id-var-ch non modifiée par la concaténation reste inchangée.

Si id-var-ch est une chaîne de n caractères, il y a débordement si la valeur du pointeur id-pointeur n'appartient pas à l'intervalle [1,n].

Exemple: 

Dans la partie déclaration : 

       1 chaine1 pic x(10).

       1 chaine2 pic x(10).

       1 chaine3 pic x(50).

Dans la partie instruction : 

move 'exemple1' to chaine1           move 'exemple2' to chaine2 string chaine1 chaine2 into chaine3

La variable chaine3 contient alors la chaine : ‘exemple1 exemple2                                   ‘

Si on remplace l’instruction string par précédente par :

string chaine1 chaine2 delimited ' ' into chaine3

La variable chaine3 contient alors la chaine : ‘exemple1exemple2                                     ‘ 

Si on remplace l’instruction string par précédente par :

string chaine1 chaine2 delimited 'p' into chaine3

La variable chaine3 contient alors la chaine : ‘exemexem                                                 ‘ 

Si on remplace l’instruction string par précédente par :

string chaine1 chaine2 delimited 'p' into chaine3 pointer lg

et en prenant la précaution d’initialiser lg à 1, on obtient :

La variable chaine3 contient alors la chaine : ‘exemexem                                               ‘    La variable lg contient la valeur : 9                                        

2.5.2Déconcaténation d'une chaîne de caractères (extraction de sous-chaînes)

Il s’agit d’extraire de ‘id-var-ch’ les sous-chaînes successives délimitées par l’un quelconque des délimiteurs cités et de les ranger, dans l’ordre, dans les variables chaînes que sont ‘id-var-ch-k ’ pour k=1, 2, . . .

La variable entière (à déclarer) ‘id-pointeur’ contient, à la fin de l’exécution de ‘unstring’, le rang dans ‘id-var-ch’ du dernier caractère concerné par la déconcaténation.

L’instruction ‘unstring’ s’arrête, par exemple, quand toutes les chaînes réceptrices sont affectées. La variable entière ‘id-var-nb-ch’ (à déclarer)  indique combien de sous-chaînes ont été extraites pendant l’exécution de ‘unstring’.

Parmi les cas de débordement on peut citer : 

              une valeur de ‘id-pointeur’ en dehors des rangs possibles de caractères dans id-var-ch  

 Il reste des caractères non examinés dans ‘id-var-ch  alors que toutes les chaînes résultat sont affectées.

Dans la partie instruction :

move 'exemple1 exemple2' to chaine3

L’exécution de l’instruction :

unstring chaine3 delimited '  ' into chaine1 chaine2

donnera comme résultat :

-  le contenu de chaîne 1 : ‘exemple1   ‘

-  le contenu de chaîne 2 : ‘exemple2   ‘

si on remplace l’instruction unstring précédente par : 

unstring chaine3 delimited ' ' into chaine1 chaine2 pointer lg

chaine1 et chaine2 contiendront les mêmes valeurs que précédemment et lg contiendra la valeur 19.

2.5.3Instruction de comptage de caractères

Le résultat du comptage est placé dans une variable entière id-var-nbcar, par ailleurs déclarée.

La variable chaine est déclarée comme  pic x(30)

move 'EFABDBCGABEFGG' to chaine           inspect chaine tallying  nb1 for all "AB", all "D";           inspect chaine tallying  nb2  for all "BC"                    ;           inspect chaine tallying  nb3 for leading "EF";           inspect chaine tallying  nb4 for leading "B";           inspect chaine tallying  nb5 for characters;

Les résultats sont :

Compte dans la variable avant les caractères blancs situés en début de la chaîne contenue dans mot.

Inspect function reverse(mot) tallying apres for leading ‘  ‘ 

Compte dans la variable apres les caractères blancs situés en fin de la chaîne contenue dans mot.

Inspect mot tallying avant for characters before space 

Compte dans la variable avant le nombre de caractères avant le premier caractère blanc. 

2.5.4Instruction de remplacement de caractères

Exemple :

Inspect texte replacing all car1 by car2

Remplace toutes le occurrences du caractère car1 par car2 dans la chaîne texte.

move 'ABBABDC' to chaine inspect chaine replacing all  "AB" by "XY", "D" by "X"

le contenu de chaine est ‘XYBXYXC’.

move 'EFABBEFABDC  EFBABC' to chaine inspect chaine replacing  leading "EF" by "TU"

le contenu de chaine est ‘TUABBEFABDC EFBABC’

move 'GARDF GHT' to chaine inspect chaine replacing first "G" by "R"

le contenu de chaine est ‘RARDF GHT’

2.5.5Instruction de comptage et remplacement

2.5.6Instruction de conversion de caractères

Chaque caractère de id-var qui apparaît dans la chaîne ‘id-var1’ (ou const1) est remplacé par le caractère de rang correspondant dans ‘id-var2’ (ou const2), éventuellement avant ou après une première occurrence dans id-var de la chaîne ‘id-var3’ (ou const3).

move ‘AC"AEBDFBCD#AB"D to chaine inspect chaine converting "ABCD" to "XYZX" after quote before "#".

le résultat est : AC"XEYXFYZX#AB"D

2.5.7Test du type de l'ensemble des caractères d'une chaîne

id-var-ch alphabetic //vrai si id-var ne contient que des lettres et des espaces id-var-ch numeric //vrai si id-var ne contient que des chiffres et un signe éventuel id-var-ch alphabetic-upper //vrai s’il n’y a que des lettres majuscules ou des espaces id-var-ch alphabetic-lower      //vrai s’il n’y a que des lettres minuscules ou des espaces

                                  CHAPITRE 5 : FONCTIONS ET SOUS-PROGRAMMES

Au niveau de Cobol les concepts contribuant à la modularité sont essentiellement ceux de programme, paragraphe, section, de fonction et de sous-programme.

Une Unité d'Exécution (UE) est constituée d'un programme principal et des éventuelles fonctions programmes et sous-programmes qu'il appelle.

1Les fonctions

En plus des fonctions prédéfinies, l'utilisateur peut définir ses propres fonctions.

Une fonction possède des paramètres formels, tous par principe paramètres d'entrée. Son appel génère une valeur du type de la fonction.

1.1Définition d'une fonction

Pour être utilisable une fonction doit être compilée  et enregistrée dans un répertoire (repository) de (signatures de) fonctions créé implicitement dans le répertoire courant.

1.1.1Enregistrement d'une fonction

Est déclenché par une commande (repository) qui précède la définition de la fonction.

L’enregistrement peut s’effectue dans le répertoire courant par la commande suivante :  

ou dans un répertoire précisé par son chemin complet (chm-rep)

$set  repository  "update on"              

L'option 'checking' de la commande repository déclenche un contrôle de conformité des profils d'appels de fonctions, dans le programme qui suit, aux signatures dans le répertoire des fonctions. 

1.1.2Déclaration d'une fonction

A condition qu'elle soit répertoriée (repository) une fonction peut être appelée dans un programme si elle est déclarée, au début de ce programme, dans le paragraphe d'étiquette 'repository' (dans la configuration section).

1.1.3Appel d'une fonction

1.1.4Sortie d'une fonction

1.2Exemple d’utilisation de fonction

Etape 1 : Définition de la fonction dans le fichier  ‘’

Etape 2 : appel de la fonction qui se trouve dans le fichier ‘’

2Les sous-programmes

Un sous-programme possède des paramètres qui, comme pour une procédure, permettent d'échanger des données avec un programme appelant.

2.1Définition d'un sous-programme

 Le passage des paramètres peut être envisagé par adresse ou par valeur.  

Avec l'option by reference on peut au moment de l'appel (call) choisir l'un ou l'autre des modes de passage.

Avec l'option by value le paramètre ne doit pas avoir une taille de plus de 8 octets (2 mots).

Chaque point d’entrée peut posséder des paramètres spécifiques pris parmi ceux qui sont déclarés dans la linkage section. A ce niveau, le passage des paramètres peut être envisagé par adresse ou par valeur. 

Au niveau du point d’entrée : o avec l’option by reference pour un paramètre on peut au moment de l’appel (call) choisir lun ou l’autre des modes de passage.

o Avec l’option by value le paramètre ne doit pas avoir une taille de plus de 8 octets

(2 mots o Avec by reference optional le paramètre effectif correspondant peut être omited

2.2Appel d’un sous-programme :

Les paramètres effectifs sont associés par rang aux paramètres formels correspondants. Le mode de passage des paramètres peut-être :

-    by reference : c’est-à-dire par adresse. Au moment du déclenchement de l’appel le paramètre formel se voit attribuer une adresse qui est celle du paramètre effectif correspondant. Toute modification du paramètre effectif est répercutée au niveau du paramètre formel dans le programme appelant.

-    by content : c’est-à-dire par valeur.  Au moment du déclenchement de l’appel, l’adresse du paramètre formel est distincte de celle du paramètre effectif. Dans ce cas, au déclenchement de l’appel, la valeur du paramètre effectif est affectée au paramètre formel. La modification de la valeur de ce dernier n’affecte en rien le contenu du paramètre effectif.

L’option exception permet de prendre le control dans le cas où, à  l’appel du sous-programme, ce dernier ne peut être chargé dynamiquement ou lorsqu’il n’y a pas assez de place mémoire.

2.3Sortie d’un sous programme

Qu’il s’agisse d’un appel du point d’entrée principal ou d’un point d’entrée secondaire, on peut sortir du corps du sous- programme.

Le goback est à privilégier.

2.4Exemples de sous-programmes

2.4.1Exemple 1 - version 1

Cette première version comporte un programme principal et deux sous-programmes permettant de calculer la somme et le produit de deux nombres. Les 2 nombres et le résultat de leur somme et leur produit apparaissent sous la forme de paramètres. 

Le programme principal correspondant au fichier :

Le sous-programme suivant correspondant au fichier :

Le sous-programme suivant correspondant au fichier :

2.4.2Exemple1 version 2 

Dans cette version les 2 sous-programmes apparaissent dans le même fichier sous la forme de 2 points d’entrée. 

Soit le programme principal suivant dans le fichier :  

et son sous programme dans le fichier :

2.4.3Exemple 2 

Soit le programme suivant correspondant au fichier :

Complété par le fichier :

Complété par le fichier :

01 varperim.

02 var-ent.

                 04 largeur        PIC 999 value 0.

                 04 longueur     PIC 999 value 0.

     02 var-sort.

                 04 code-er       PIC XX  value '00'.

                  04 mes-erreur PIC X(40) value spaces.

                 04 perimetre    PIC 9(6) value 0.

                                                              CHAPITRE 6 : LES TABLEAUX

1Exemples de déclaration de tableaux

A - Tableau à une dimension

1  tab.

2  entier pic 9 occurs 30.

B - Tableau à 2 dimensions

1  tab.

2  ligne  occurs 3.

3  element pic 9 occurs 5.

C - Tableau avec structure

1  tab.

2  ligne-carre occurs 30.

3  element occurs 5.                   4 entier pic 99.

4  carre pic 9(5).

2Exemple détaillé n°4

1                                                 30

entier(i) accès au i^eme élement 

Ligne(i) : accès à 1 ligne complète Element(i,j) : accès à une cellule 

La première version de ce programme permet d’afficher les nombres de 1 à n avec leurs carrés.

Cette 2^ème version permet une meilleure gestion des écrans d’affichage (25 lignes et 80 caractères maxi).

3Déclaration d’un tableau

3.1Déclaration d'un tableau t de taille fixe (decl-tab)

Il s'agit d'un tableau de val-ent (ou const-ent) éléments dont le type est défini en amont (id-type) ou décrit par descr-type.

3.2Déclaration d'un tableau t de taille variable (decl-tab)

Le nombre effectif d'éléments (taille-t) est donc compris entre les valeurs taille-min (ou 1 par défaut) et taille-max.

Il est recommandé d'accompagner la déclaration du tableau de la déclaration de la variable (taillet) qui doit indiquer la taille courante du tableau.

3.3Déclaration d'un type tableau

Il suffit de préciser la clause typedef  au niveau d'une structure (st-t) contenant uniquement la déclaration tableau (decl-tab).

             1 st-t  typedef.                       decl-tab

4Les accès

4.1Accès à un élément d'un tableau : variable indicée

4.2Accès à un champ (id-chp) d'un élément de type structure d'un tableau

 où s'il est nécessaire de qualifier, pour lever toute ambiguïté, 

4.3Accès par référence modifiée

4.3.1A partir du tableau dans son entier

  t ( rang-deb : long )

4.3.2A partir d'une variable indicée

4.4Accès au début d'un tableau

  t  ou t ( 1 )   

pour accéder au premier élément du tableau.

5Affectation

Ce sont les instructions move et compute vues précédemment. Elles s'appliquent à tout ou partie d'un tableau, sachant que compute ne concerne dans sa partie droite que des éléments simples numériques, en particulier pas de référence modifiée.

Ne pas oublier qu'un tableau, une partie de tableau ou toute référence modifiée est considéré comme de type chaîne de caractères. 

6Initialisation

6.1Statiques (lors de la déclaration du tableau)

6.1.1Au niveau du tableau

                              Il y a affectation de val-ch à la chaîne de caractères que représente le tableau en

            mémoire

6.1.2Au niveau de chaque (partie d' ) élément

 La valeur val est affectée à toutes les occurrences de l'élément ou partie d'élément dans la description duquel elle apparaît.

6.1.3A l'aide d'une redéfinition

6.2Dynamiques

Utilisation de l'instruction move [all]  ou de l'instruction initialize sur le tableau dans son ensemble (initialisation de chaque partie d'élément à 0 ou espace selon son type) ou utilisation de ces mêmes instructions au niveau (d'une partie) de l'élément dans une itération.

7Saisie et affichage d'un tableau

7.1Elément par élément

Il suffit d'associer, dans sa déclaration, à un champ d'écran l'élément courant (ou la partie d'élément courant) à saisir ou afficher et d'itérer sur l'instruction de saisie ou d'affichage.

7.2En bloc

Il suffit d'associer au tableau à saisir ou à afficher une plage contenant un tableau de champs d'écran de même dimension et d'associer, dans sa déclaration, à chaque champ d'écran le nom de l'élément ( ou partie d'élément) de tableau à saisir ou à afficher.

Dés lors il suffit d'une seule instruction impérative de saisie ou d'affichage au niveau de la plage d'écran.

8Tri des éléments d'un tableau

Le tri peut être effectué sur des arguments explicites cités dans l'instruction de tri ou sur des arguments implicites déclarés au moment de la déclaration du tableau.

8.1Tri sur des arguments explicites

Avec id-var-ind élément courant t ou partie de t 

Exemple : 

 L’instruction sort entier ascending permet de trier le tableau par ordre croissant. 

8.2Tri sur des arguments implicites

Dans la clause occurs apparaissent les arguments de tri par défaut du tableau

et dans ce cas l'instruction de tri à l'appui des arguments implicites s'écrit : 

  sort t [duplicates] 

9Tableaux à plusieurs dimensions 

En Cobol il s'agit de tableaux de tableaux et pour cela il suffit d'introduire la clause occurs dans la déclaration d'une partie d'élément de tableau (imbrication d' occurs). Introduire alors dans la variable indicée, accès à un élément, autant d'indices qu'il y a d' occurs imbriqués pour  accéder à la déclaration de cet élément. 

                                                               CHAPITRE 7 : LES FICHIERS  

1Introduction

Un fichier est un ensemble de données qui peut être vu :

                du point de vue informationnel, il s’agit du fichier logique

 du point de vue de sa mémorisation et de sa gestion par le SGF (Système de Gestion des Fichiers), il s’agit du fichier physique.

Un fichier logique est un ensemble d’enregistrement le plus souvent de même type (en général une structure). 

Le  SGF gère les fichiers physiques répertoriés dans un catalogue des fichiers.

Chaque élément du catalogue contient au moins le nom du fichier physique (), l'identifiant du propriétaire, l'adresse de début du fichier. Un fichier physique est composé d'une suite d'enregistrements le plus souvent du même type.

Chaque enregistrement, unité d'accès aux données du fichier physique, est composé des données d'un article et éventuellement d'un entête d'enregistrement voire d'un marqueur de fin d'enregistrement.  

2Les fichiers séquentiels

Les enregistrements, tous de même taille, sont consécutifs sur le support et ne sont constitués que des données des articles (pas d'information système). Chaque enregistrement possède un unique enregistrement prédécesseur et un unique enregistrement successeur. Et cela dans l’ordre où les enregistrements ont été ajoutés dans le fichier.

L’accès séquentiel consiste, pour accéder à un enregistrement, à accéder à tous ses prédécesseurs dans l’ordre où ils sont dans le fichier.

En Cobol on dispose de trois organisations différentes de fichiers séquentiels intitulées  record sequential : organisation séquentielle par enregistrements (données structurées), c'est, en général, l'organisation par défaut

 line sequential : organisation séquentielle par lignes qui est celle des fichiers texte des éditeurs sur PC

                printer sequential : organisation séquentielle directement adaptée à l'impression

2.1Partie des déclarations

La déclaration d'un fichier est constituée : 

     d'une phrase select (caractéristiques du fichier physique)   d'une déclaration de niveau  fd (caractéristiques du fichier logique)

2.1.1Phrase select 

S’effectue dans la file-control de l' input-output section.

 Déclaration des caractéristiques du fichier physique ('' ou id-var-fs)  assigné au fichier logique (id-fs)  et du mot d'état associé (id-mot-etat).

2.1.2Déclaration du fichier logique  S’effectue dans la  file section.

Cas de la déclaration d'un fichier logique à longueur variable d'article

              fd     id-fs  record varying  [long-min]  to  [long-max]  [depending id-var-long] .              

 la variable entière id-var-long, à déclarer, reçoit en lecture ou permet d'indiquer en  écriture, la longueur de l'article en nombre de caractères.

2.2Partie des instructions

2.2.1Instructions globales sur un fichier 

2.2.1.1Instruction d'ouverture d'un fichier (création si nécessaire)

o    l'ouverture en 'output' permet de remplacer l'ancien contenu du fichier.

o    la clause 'optional' de la phrase select permet d'ouvrir directement en 'extend' un  fichier non encore existant. 

o    la clause 'reversed' permet la lecture arrière du fichier

2.2.1.2Instruction de fermeture du fichier

              close id-fs

2.2.2Instructions élémentaires sur un fichier

2.2.2.1Instruction de lecture (séquentielle) d'un article (ouverture en input ou i-o)

o    la clause 'end' détecte l'adresse de fin de fichier lors d'une tentative de lecture.

o    la clause 'into' affecte un exemplaire de l'article lu à id-var.

2.2.2.2Instruction d'écriture (séquentielle) d'un article (en output ou extend)

2.2.2.3Instruction de réécriture (séquentielle) d'un article (en i-o)

            La réécriture doit être précédée d'une lecture réussie de l'article.

2.3Exemple détaillé n°5

Le programme suivant concerne la consultation d’un fichier séquentiel. Il s’agit d’effectuer un traitement par le module mod-trait-produit de tous les produits figurant dans le fichier. 

2.4Complément sur le traitement des fichiers séquentiels

Les opérations que l’on peut avoir à mettre en œuvre, dans le cadre de sa mise à jour sont :

o l’adjonction d’articles, au milieu ou en fin de fichier o la modification du contenu de certains articles o la suppression d’articles

La réalisation de la mise à jour peut être faite selon deux modes, le mode temps différé ou le mode interactif.

Dans le mode temps différé, les modifications à apporter au fichier à mettre à jour sont cumulées pendant une certaine période, généralement dans un fichier séquentiel des mises à jour. Le programme temps différé qui prend en compte ces modifications s’exécute en l’absence de l’utilisateur.

Dans le mode interactif, le programme s’exécute en présence de l’utilisateur qui saisit, au fur et à mesure, les modifications à apporter au fichier à mettre à jour, modifications non préalablement enregistrées. 

En terme d’efficacité, les fichiers séquentiels ne s’accommodent guère que du mode de mise à jour temps différé. On procède, toutefois en interactif, lors du chargement initial d’un fichier (version initiale du fichier de base qui sera à maintenir ultérieurement ou création d’un fichier des modifications) ou lors de l’extension, par la fin d’un fichier.

La mise à jour d’un fichier séquentiel peut être organisée de deux manières :

o    mise à jour sur place 

Les modifications sont faites sur la version courante du fichier à mettre à jour. Ce qui n’empêche pas de faire une copie préalable du fichier pour des raisons de sécurité : on procède à une sauvegarde de ce fichier. Dans ce type de mise à jour, les seules opérations possibles sur le fichier sont :

 la modification des contenus d’enregistrements existants : nécessite une ouverture en modification. Il faut accéder à l’enregistrement à modifier en passant par les prédécesseurs, puis réécrire dessus.

     l’adjonction d’enregistrements en fin de fichier : nécessite une ouverture en extension, d’où un positionnement en fin de fichier. Il suffit, alors, d’écrire, un à un, les enregistrements à ajouter.

o    mise à jour par recopie

Dans ce cas on crée, par le biais du programme de mise à jour, une nouvelle version du fichier à mettre à jour : le fichier mis à jour.

Dès lors toutes les opérations élémentaires sont possibles. Outre la modification de contenu d’un enregistrement et l’adjonction d’un enregistrement en fin de fichier on peut :

     supprimer un enregistrement : il suffit de ne pas le recopier dans la nouvelle version du fichier

 insérer un enregistrement entre deux autres : il suffit de l’écrire au bon moment au cours de la recopie du fichier.

Remarque :

Il en ressort que les fichiers séquentiels ne sont pas adaptés au mode ‘interactif’ de mise à jour et que le mode ‘temps différé’ nécessite de trier le fichier des modifications sur les mêmes critères que le fichier à mettre à jour et de procéder, alors, à un  parcours interclassé des deux fichiers.

2.5Le tri d'un fichier séquentiel

Il s'agit de classer entre eux les articles d'un fichier en fonction des valeurs d'un ou de plusieurs champs des articles désignés comme arguments du tri. 

En Cobol une instruction (sort) permet d'effectuer le tri d'un fichier. Cette instruction met en œuvre trois fichiers:

            -le fichier à trier soit f-à-trier

            -un fichier temporaire intermédiaire soit f-inter-tri

            -le fichier trié soit f-trié

Quant au tri il se déroule automatiquement en trois phases:

     chargement du fichier intermédiaire f-inter-tri avec les enregistrements du fichier à trier fà-trier

 tri du fichier intermédiaire f-inter-tri sur les arguments indiqués avec le résultat du tri dans f-inter-tri

               chargement du fichier résultat f-trié avec les enregistrements ordonnés du fichier f-inter-tri

Dans le programme Cobol, les fichiers séquentiels  f-à-trier et f-trié se déclarent comme on l'a vu précédemment.

 Le fichier temporaire fait l'objet d'une phrase 'select' minimum, 

  select f-inter-tri  assign  'f-inter-tri'.

et sa déclaration doit contenir au niveau de l'article les champs (id-ch-argj) qui sont arguments du tri. 

La déclaration du fichier intermédiaire s'écrit donc,

L'instruction de tri d'un fichier s'écrit:

La clause 'using' assure le chargement de f-inter-tri avec les enregistrements de f-à-trier, puis le tri de f-inter-tri s'effectue et enfin la clause 'giving' transfère les enregistrements classés de finter-tri dans f-trié.

Une variante de l'instruction de tri consiste à mettre en œuvre à la place des clauses 'using' et/ou 'giving' des procédures pour assurer respectivement le chargement et/ou le 'déchargement' du fichier intermédiaire du tri.

L'instruction de tri d'un fichier s'écrit alors:

Dans la procédure d'entrée du tri, constituée d'un ou de plusieurs paragraphes ou sections, le fichier intermédiaire est automatiquement, à l'entrée de la procédure, ouvert en écriture et fermé à la sortie. 

L'instruction d'écriture dans le fichier intermédiaire s'écrit,

                                                                                                          *>instruction équivalente à un 'write'

Dans la procédure de sortie du tri, constituée d'un ou plusieurs paragraphes ou sections et exécutée après la deuxième phase du tri, le fichier intermédiaire est automatiquement ouvert en lecture au début et fermé à la fin.

Il s'agit de lire un à un les articles du fichier intermédiaire pour pouvoir les traiter.

L'instruction de lecture spécifique d'un fichier intermédiaire de tri s'écrit,

  *>instruction équivalente à un 'read'

A l'instruction 'sort' est associé automatiquement, sans déclaration, un registre d'état du tri 'sortreturn' positionné,

            -à 0 si le tri s'est bien déroulé

            -à 16 si le tri a échoué

Il est possible de positionner impérativement (set sort-return to 16) ce registre à la valeur 16 dans les procédures d'entrée et/ou de sortie du tri pour interrompre immédiatement le tri à la rencontre de la prochaine exécution de l'instruction 'release' ou 'return'.

2.6La fusion de plusieurs fichiers séquentiels

La fusion de plusieurs fichiers (id-fichierk) tous supposés triés dans le même ordre sur le même ensemble d'arguments (id-chp-argj) consiste en l'interclassement de leurs articles dans un seul fichier résultat lui-même finalement classé dans le même ordre. 

L'instruction de fusion de plusieurs fichiers s'écrit:

Le résultat de la fusion peut être copié dans plusieurs fichiers (id-fichier-resn).

Comme dans l'instruction 'sort' la procédure de sortie permet d'accéder un à un aux articles fusionnés dans le fichier intermédiaire f-inter-fusion grâce à l'instruction 'return'.

Le résultat de la fusion est chargé dans chacun des fichiers de la liste 'giving' ou pris en compte dans la procédure de sortie par des 'return' .

2.7Création d’un fichier de données sous NetExpress

La création d’un fichier de données comporte deux  étapes :

A - Allocation du fichier peut se faire soit directement sous NetExpress soit indirectement par un programme cobol.

B- Chargement des données dans le fichier peut s’effectuer directement sous NetExpress, à l’aide d’un programme cobol ou plus simplement par conversion d’un fichier déjà existant.

La démarche suivante permet de créer un fichier sous NetExpress :

1)    Allocation du fichier :

Fichier New Data File  Définir la longueur de l’enregistrement et la position de la clé primaire

Donner un nom au fichier :

2)    Créer un programme cobol dans un projet contenant la description d’un enregistrement en accès séquentiel ou direct :

Exemple de programme : 

3)    Compiler le projet.

4)    Sélectionner le projet contenant la structure et faire clic droit, choisir New record layout. L’objectif est de créer un fichier ‘.str’ à partir de la structure définie dans la programme pour avoir un modèle d’enregistrement.

5)    Enregistrer le fichier .str et fermer.

6)    Ajouter le fichier .dat au projet.

7)    Ouvrir le fichier .dat.

8)    Faire Fichier DataTools New record layout et choisir le bon fichier .str .

9)    Sur la partie droite faire clic droit et choisir insert indexed record (si le fichier est direct). 10)  Insérer la clé et la suite de l’enregistrement de manière assistée.

Concernant la conversion, il suffit de choisir Fichier DataTools Convert et de saisir les informations du fichier à convertir et du fichier à créer.

3Les fichiers directs

On distingue les fichiers relatifs et les fichiers indexés.

3.1Le fichier relatif

Un fichier relatif est constitué d’une suite d’emplacements ‘consécutifs’ en mémoire externe.

Chaque emplacement a une adresse relative qui correspond à son rang (de 1 à n) dans le fichier. 

La clé d’accès du fichier est le rang des emplacements dans le fichier.

Chaque emplacement est susceptible de contenir un enregistrement du fichier. Il existe un bit de chargement par emplacement. Un emplacement peut être ‘chargé’, un enregistrement y a été écrit ou ‘non chargé’, aucun enregistrement n’y a été écrit ou son contenu a fait l’objet d’un effacement.

L’accès dans un fichier relatif, géré par le SGF peut être séquentiel ou direct :

 l’accès séquentiel est assuré dans l’ordre croissant des valeurs de la clé d’accès du fichier (rangs des emplacements) aux seuls emplacements chargés, s’est à dire automatiquement aux seuls enregistrements existants dans le fichier.

 l’accès direct à un emplacement pour une valeur donnée de la clé d’accès du fichier (un rang donné) et donc accès à l’enregistrement contenu s’il en existe un.

3.2Le fichier indexé

Dans un fichier indexé, la clé d’accès du fichier est constituée d’un ou de plusieurs champs, simples ou structurés, de l’article du fichier. Un fichier indexé est, en fait, constitué de deux fichiers physiques :  le fichier des données, les enregistrements effectifs du fichier.

                       le fichier ‘index’ dont chaque élément est constitué :

o    d’une valeur de la clé d’accès (entrée de la table représentée par le fichier indexé)

o    de l’adresse, dans le fichier de données, de l’article associé à cette valeur de clé d’accès

Remarques : 

La clé d’accès d’un fichier indexé est de type quelconque.

Le fichier ‘index’ est ordonné par valeurs croissantes de la clé et généralement partitionné. Contrairement au fichier relatif, il n’y a pas d’emplacements prédéfinis, seuls les articles correspondant à des valeurs effectives de la clé d’accès (entrées de la table) sont mémorisés.

Le SGF gère deux types d’accès dans un fichier indexé :

 l’accès séquentiel : C’est l’accès aux enregistrements dans l’ordre croissant des valeurs de la clé d’accès du fichier. Cet accès implique la consultation séquentielle automatique du fichier index par le ‘SGF’.

 l’accès direct : C’est l’accès direct à un enregistrement, étant donnée la valeur de clé d’accès qui le caractérise. Cela implique la consultation ‘directe’ automatique du fichier ‘index’ par le ‘SGF’ pour obtenir l’adresse de l’article ayant cette valeur de clé.

Les opérations sont identiques pour les deux types de fichiers directs, à ceci près que pour un fichier relatif la clé d’accès est représentée par une variable entière associée au fichier, au moment de sa déclaration dans un programme, alors que pour un fichier indexé, c’est un ou plusieurs champs de l’article qui jouent le rôle de clé d’accès.

3.3Déclarations des fichiers directs

3.3.1Déclaration d'un fichier relatif

La clé du fichier, souvent appelée clé relative (id-cle-rel) doit être déclarée comme variable entière dans le programme.

Si, dans le cas de l'accès séquentiel, une clé (id-cle-rel ) est associée au fichier le SGF la valorise avec le rang de l'article courant pendant le parcours séquentiel du fichier.

En accès direct (random) ou mixte (dynamic) il est nécessaire d'associer une clé (id-cle-rel) au fichier pour réaliser les accès directs.

La déclaration de niveau 'fd' en file section : est semblable à celle d'un fichier séquentiel. A noter toutefois que la clé relative (id-cle-rel) ne peut pas être un champ de l'article du fichier.

3.3.2Déclaration d'un fichier indexé

La clé du fichier (souvent appelée clé indexée) doit être un champ de son type d'article (id-cleind) ou une clé composée de la concaténation d'un certain nombre de champs (non consécutifs) de ce type d'article (id-cle-comp).

La déclaration de niveau 'fd' en file section : est semblable à celle d'un fichier séquentiel. A noter toutefois que la clé du fichier doit faire partie du type d'article du fichier.

3.3.3Instructions sur les fichiers directs

Les opérations élémentaires sont de type séquentiel ou direct, leur mise en œuvre dépend de l'accès choisi pour le fichier et du type de période d'accessibilité.

Les instructions sont les mêmes pour un fichier relatif ou un fichier indexé, à ceci près qu'elles mettent en œuvre dans un cas une clé relative dans l'autre cas une clé indexée.

3.3.3.1Définition d'une période d'accessibilité Entre l'ouverture et la fermeture du fichier

  close id-fich-dir

3.3.3.2Instructions élémentaires

A  - Lecture séquentielle d'un article

Contextes de mise en oeuvre:

 'access sequential' ou 'access dynamic'

 'open input' ou 'open i-o'

 Les options 'next' (lecture séquentielle en avant) et 'previous' (lecture séquentielle en arrière) sont restreintes à 'access dynamic'.

B  - Lecture directe d'un article

Avant d'exécuter une lecture directe la clé du fichier (id-cl-rel, id-cle-ind ou id-cle-comp), déclarée dans la phrase 'select', doit être valorisée. Contextes de mise en œuvre:

            'access random' ou 'access dynamic'

            'open input' ou 'open i-o'

C- Ecriture séquentielle ou directe d'un article

Contextes de mise en oeuvre:

       écriture séquentielle o 'open output' o 'access sequential'

o    Pour un fichier relatif le SGF charge automatiquement l'emplacement suivant dans le fichier.

o    Pour un fichier indexé le programme doit préciser avant chaque exécution du 'write' la valeur de la clé pour l'article à écrire

o    L'option 'invalid' sert pour un fichier indexé à prendre le contrôle s'il n'y a pas respect de l'ordre croissant des valeurs de la clé à chaque écriture.

 écriture directe o 'open output' ou 'open i-o' o 'access random' ou 'access dynamic'

o    L'option 'invalid' permet de prendre le contrôle si

                                    -pour un fichier relatif l'emplacement concerné est déjà chargé

                                    -pour un fichier indexé il existe déjà un article ayant même valeur de clé

D- Recherche (de l'adresse donc de l'existence) d'un article

La recherche est effectuée par rapport à la valeur de clé indiquée dans id-clé.

Contextes de mise en oeuvre:

                       'open input' ou 'open i-o'

                       'access sequential' ou 'access dynamic'

                      Pour un fichier relatif, la clé id-clé est la clé relative (id-cle-rel).

 Pour un fichier indexé, la clé id-clé est la clé indexée (id-clé-ind ou id-clé-comp) ou toute partie de la clé indexée commençant par son premier caractère (cas où on ne connaît que les premiers caractères de la valeur de clé de l'article recherché).

 Cette première partie de clé peut être indiquée à l'aide du nom d'un champ début de la clé, à l'aide d'une référence modifiée ou grâce à l'option 'size' en indiquant le nombre de caractères à prendre en compte en partant du début de la clé.

Remarque:

L'instruction 'start' ne délivre aucune donnée mais, si elle s'exécute correctement, place un pointeur à une adresse précise d'un article dans le fichier.

E-réécriture séquentielle ou directe d'un article

Contextes de mise en oeuvre:  'open i-o'

 Dans le cas de 'access sequential' l'instruction 'rewrite' doit être précédée d'une lecture réussie et la valeur de la clé doit être la même que pour la lecture, de plus l'option '(not) invalid' n'est pas autorisée.

 Dans le cas de ''access random' ou 'access dynamic' la réécriture est directe (pas de lecture préalable indispensable) et l'option '(not) invalid' permet de prendre le contrôle en cas d'échec de la réécriture.

F- Séquentiel ou direct d'un article

Contextes de mise en œuvre:

               'open i-o'

 Dans le cas de 'access sequential' l'instruction 'delete' doit être précédée d'une lecture réussie et la valeur de la clé doit être la même que pour la lecture, de plus l'option '(not) invalid' n'est pas autorisée.

 Dans le cas de ''access random' ou 'access dynamic' l'effacement est direct (pas de lecture préalable indispensable) et l'option '(not) invalid' permet de prendre le contrôle en cas d'échec de l'effacement.

G-Cas particulier d'opération globale sur un fichier : effacement du fichier

  Il est possible d'effacer 'physiquement' un (ou plusieurs) fichier(s) du catalogue des fichiers à condition qu'au moment de son effacement le soit fermé et non verrouillé.

  delete file liste [ ] de id-fich 

3.4Les fichiers indexés multi-tables (ou multi-clés)

3.4.1Déclaration d'un fichier indexé multi-clés

Un fichier indexé possède nécessairement une clé primaire (record key) simple (id-clé-ind) ou composée (id-clé-comp) mais peut aussi posséder des clés secondaires (alternate key) simples ou composées pour chacune desquelles est géré également automatiquement un fichier index spécifique.

La déclaration du fichier, inchangée au niveau 'fd', déclare toutes les clés au niveau de la 'phrase select'.

Les clés secondaires simples (id-cle-sec) ou composées (id-cle-cp-sec) peuvent être utilisées comme la clé primaire et de plus peuvent être ambiguës à condition d'ajouter l'option 'duplicates'. Pendant une période d'accessibilité au fichier multi-clés la clé courante, par défaut la clé primaire (id-clé-ind ou id-clé-comp) peut être changée grâce aux instructions 'read' ou 'start'.

Exemple :

select fpret assign ' ' organization indexed        record key is clef = dateP, RefS, CodeE        alternate key RefS duplicates        alternate key CodeE duplicates        access dynamic.

       Fd fpret.

1 enrEmprunt.

2 DateP pic 9(8).

2 RefS pic x(5).

2 CodeE pic x(30).

2 DateRetour pic 9(8).

3.4.2Instructions et clés secondaires

A- lecture directe d'un article

Contextes de mise en oeuvre:

               'access random' ou 'access dynamic'

               'open input' ou 'open i-o'

Cette instruction de lecture directe indique la clé primaire ou secondaire à mettre en œuvre comme nouvelle clé courante, à partir de cet instant, pour toutes les opérations élémentaires sur le fichier et assure automatiquement l'accès au fichier index correspondant. 

B-Recherche (de l'adresse ou de l'existence) d'un article

Contextes de mise en oeuvre:

                'access sequential'  ou 'access dynamic'

                'open input'  ou  'open i-o'

L'instruction de recherche de l'adresse ou de l'existence d'un article satisfaisant à une condition sur la valeur de sa clé offre donc aussi, comme l'instruction de lecture directe, l'occasion de préciser en même temps, quelle est la nouvelle clé courante (primaire ou secondaire) pour le fichier. 

C-Lecture séquentielle d'un article

Contextes de mise en oeuvre:

                'access sequential' ou 'access dynamic'

                'open input' ou 'open i-o'

L'option 'end' permet de prendre le contrôle en cas de  dépassement de l'adresse de fin de fichier en lecture avant (next) ou de dépassement de l'adresse de début de fichier en cas de lecture arrière (previous).

Remarque :

Les lectures séquentielles peuvent apparaître à la suite d'une instruction de recherche (start) ou d'une lecture directe (read). 

4Exemple détaillé n°6 

L’exemple considéré concerne la mise à jour d’un fichier direct de produits f-prod à partir d’un fichier séquentiel foper des opérations de la journée. 

Les opérations à mettre en œuvre sont : la création d’un produit nouveau, la suppression d’un produit et la modification d’un produit. Les messages d’erreurs éventuels sont stockés dans un fichier séquentiel fmessage.

5Exemple détaillé n°7 

Programme permettant d’afficher tous les véhicules de marque Peugeot 207 dans un fichier avec une clé primaire et une clé secondaire dupliquée. 

ANNEXES

                                                      LISTE DES FONCTIONS PREDEFINIES

The "arguments" column defines argument type and the "type" column defines the type of the function, as follows: 

LENGTH                 Alph1 or Anum1 or            Int               Length of argument in number of

Nat1              character positions  or Num1 

LENGTH-AN Alph1 or Anum1 or Int Length of argument in number of Int1 or Nat1 or alphanumeric character positions  Num1 

LOG                        Num1                               Num          Natural logarithm of Num1 

LOG10                    Num1                               Num          Logarithm to base 10 of Num1 

LOWER-CASE          Alph1 or Anum1 or Depends upon All letters in the argument are set to

                                                   Nat1                      argument      lowercase

MAX                        Alph1 or Anum1 Depends upon Value of maximum argument

or Int1 or arguments*

                                                   Nat1         or

Num1

MEAN                     Num1                            Num          Arithmetic mean of arguments

MEDIAN                 Num1                            Num          Median of arguments

MIDRANGE            Num1                            Num             Mean of minimum and maximum

arguments

MIN                         Alph1 or Anum1 Depends upon Value of minimum argument

... or Int1 or arguments*

                                                   Nat1         or

Num1

MOD                       Int1, Int2                            Int           Int1 modulo Int2

          NATIONAL-     Anum1,                              Nat              Usage national representation of

OF                                  Nat1                                            argument Anum1

NUMVAL                Anum1                 or          Num              Numeric value of simple numeric

                                                   Nat1                                            string 

NUMVAL-C Anum1, Anum2, or Num Numeric value of numeric string with Nat1, Nat2 optional commas and currency sign 

ORD                        Alph1 or Anum1 or            Int             Ordinal position of the argument in

                                                   Nat1                                            collating sequence

ORD-MAX               Alph1 or Anum1            Int           Ordinal      position      of      maximum

                                         ...                          or                           argument 

                                                   Nat1         or

Num1 

ORD-MIN                Alph1 or Anum1            Int           Ordinal      position      of      minimum

                                         ...                          or                           argument 

                                                   Nat1         or

Num1 

          PI                    None                                  Num          Value of

PRESENT-VALUE Num1 Num2                  Num             Present value of a series of future

period-end amounts, Num2, at a discount rate of Num1

RANDOM               Int1                                   Num          Random number

RANGE Int1 or Num1  Depends upon Value of maximum argument minus arguments* value of minimum arguments

REM                       Num1, Num2                    Num          Remainder of Num1/Num2 

REVERSE                Alph1 or Anum1 or Depends upon Reverse order of the characters of the

                                                   Nat1                      argument      argument

          SIGN               Num1                                  Int           The sign of Num1 

SIN                         Num1                               Num          Sine of Num1 

SQRT                      Num1                               Num          Square root of Num1 

              LISTE DES OPTIONS POUR LES ENTREES-SORTIES EN PLEIN ECRAN

                                                TABLE DES CARACTÈRES ASCII ÉTENDU

La norme ASCII (American Standard Code for Information Interchange), a longtemps été utilisée pour le codage de caractères en informatique. Elle a été inventée par l'américain Bob Bemer en 1961. Encore aujourd'hui, la table ASCII est grandement utilisée, même si parfois complétée par une table étendue.

                                                        caractère                                              code ASCII code hexadécimal

5                                  53   35

6                                  54 36 7      55 37 8            56 38 9        57 39 :             58 3A ;            59 3B <           60 3C =           61 3D >        62 3E ?            63 3F @           64 40

A                                    65   41

B                                    66   42

C                                    67   43

D                                    68   44

E                                    69   45

F                                    70   46

G                                    71   47

H                                    72   48

I                                   73 49 J      74 4A K           75 4B

L          76 4C M          77 4D N           78 4E O           79 4F P            80 50

Q                                    81   51

R                                    82   52

S                                    83   53

T                                  84   54

U                                    85   55

V                                    86   56

W                                   87   57

X                                    88   58

Y                                    89 59 Z      90 5A [            91 5B

\          92 5C ]            93 5D ^           94 5E _            95 5F `            96 60 a            97 61 b          98 62 c            99 63 d            100 64 e          101 65 f           102 66 g          103 67 h          104 68 i           105 69 j           106 6A k         107 6B l          108 6C m        109 6D n    110 6E o         111 6F p         112 70 q          113 71 r          114 72

TABLE DES MATIERES

CHAPITRE 1 : INSTRUCTIONS ET TYPES ELEMENTAIRES ..1

1     Introduction ..1

2     Structure générale d’un programme Cobol ..1

3     Exemple détaillé n°1 ..1

3.1   Le programme .1

3.2   Les commentaires du programme ..3

      4                Partie des déclarations .4

4.1   Section des constantes et des variables (working-storage section) 4

4.2   Section des plages et champs d'écran : screen section ..5

      5                La partie des instructions 7

5.1 Instructions d'affectation 7 5.2 Instruction d'initialisation .7 5.3 Instruction de saisie .7

5.4   Instruction d'affichage .8

5.5   Gestion des date et heure courantes .8

5.6   Instructions d'arrêt d'exécution d'un programme 9 6 Complément sur l’utilisation de fichiers externes 9

      7                 Notion de fonction 10

7.1   Les fonctions prédéfinies .10

7.2   Les fonctions utilisateur ..10

CHAPITRE 2 : TYPE STRUCTURE ET INSTRUCTIONS DE CONTROLE ..11

1     Exemple détaillé n°2 11

2     Définition de structure ..12

2.1             Déclaration d’une structure 12 2.2       Déclaration d'un type structure 12

           2.3         Déclaration d'un type alternatif 13

      3               Notion de paragraphe ..14

3.1   Appel d’un paragraphe .14

3.2   Sortie d’un paragraphe .14

      4                Les instructions de contrôle 15

CHAPITRE 3 : LES ITERATIONS ..16

      1                 Itération portant sur une instruction composée 16

1.1             Itération un nombre de fois connu ..16 1.2       Itération avec condition 16

           1.3          Itération avec gestion d'une variable ..18

      2                Instructions d'itération portant sur un module bloc 19

2.1   Itération d'un module bloc ..19

2.2   Instructions de sortie d'un appel itératif d'un module bloc ..19

      3                Exemple détaillé n°3 20

CHAPITRE 4 : LE TYPE CHAINE DE CARACTERES 21

      1                 Partie Déclaration (en working-storage section) .21

1.1             Descripteur de type chaîne de caractères .21 1.2       Déclaration d'une constante de type chaîne 21

1.3             Déclaration d'une variable simple (variable alphanumérique) ..21 1.4       Déclaration d'une variable de type structure (cas particulier de variable chaîne) .21

           1.5          Déclaration d'un type chaîne de caractères .21

      2                Manipulation de chaîne de caractère ..21

2.1   Accès à une sous-chaîne (référence modifiée) .21

2.2   Affectation d'une valeur à une variable de type chaîne de caractères 22

2.3   Comparaison de chaînes de caractères .22

2.4   Quelques fonctions prédéfinies sur les chaînes de caractères .22

2.5   Instructions spécifiques sur chaînes de caractères ..23 CHAPITRE 5 : FONCTIONS ET SOUS-PROGRAMMES .27

      1                Les fonctions ..27

1.1   Définition d'une fonction .27

1.2   Exemple d’utilisation de fonction .28

      2               Les sous-programmes ..29

2.1 Définition d'un sous-programme ..29 2.2 Appel d’un sous-programme : 30

2.3   Sortie d’un sous programme ..30

2.4   Exemples de sous-programmes 31

CHAPITRE 6 : LES TABLEAUX .36 1 Exemples de déclaration de tableaux ..36

2     Exemple détaillé n°4 36

3     Déclaration d’un tableau 38

3.1 Déclaration d'un tableau t de taille fixe (decl-tab) .38 3.2 Déclaration d'un tableau t de taille variable (decl-tab) 38

           3.3          Déclaration d'un type tableau 39

      4               Les accès ..39

4.1 Accès à un élément d'un tableau : variable indicée ..39 4.2 Accès à un champ (id-chp) d'un élément de type structure d'un tableau 39

4.3     Accès par référence modifiée ..39

4.4     Accès au début d'un tableau .39 5 Affectation 39

      6                Initialisation 40

6.1   Statiques (lors de la déclaration du tableau) 40

6.2   Dynamiques ..40

      7                Saisie et affichage d'un tableau ..40

7.1   Elément par élément .40

7.2   En bloc 40

      8               Tri des éléments d'un tableau .41

8.1   Tri sur des arguments explicites ..41 Exemple : ..41

8.2   Tri sur des arguments implicites .41

      9               Tableaux à plusieurs dimensions 41

CHAPITRE 7 : LES FICHIERS ..42 1 Introduction 42

      2                Les fichiers séquentiels ..42

2.1 Partie des déclarations .42 2.2 Partie des instructions .43

2.3   Exemple détaillé n°5 ..44

2.4   Complément sur le traitement des fichiers séquentiels ..45 2.5 Le tri d'un fichier séquentiel ..45 2.6 La fusion de plusieurs fichiers séquentiels ..48

           2.7         Création d’un fichier de données sous NetExpress ..49

      3                Les fichiers directs ..49

3.1 Le fichier relatif 49 3.2 Le fichier indexé ..50 3.3 Déclarations des fichiers directs ..50

3.4 Les fichiers indexés multi-tables (ou multi-clés) 53 4 Exemple détaillé n°6 55

      5                Exemple détaillé n°7 58

ANNEXES .60

LISTE DES FONCTIONS PREDEFINIES .60

LISTE DES OPTIONS POUR LES ENTREES-SORTIES EN PLEIN ECRAN .63

TABLE DES CARACTÈRES ASCII ÉTENDU .64

---