Discussion :

[marc.bichara]

Bonjour,

Je vous propose un nouvel élément à utiliser : Remplacer chaine par une chaine de longueur différente

INSPECT REPLACING en Cobol ne permet de remplacer dans une chaine de caractères une chaine spécifique que par une chaine de meme longueur.

Ainsi vous pouvez donner l'ordre

INSPECT w-ZONE replacing "TOTO" by "ZOZO", mais vous avez une erreur si vous donner l'ordre

INSPECT w-ZONE replacing "TOTO" by "T"le code qui suit donne une méthode pour le faire par une astuce et sans trop se fatiguer dans l'exemple donné on remplace " 000000;" par ";"

voila la portion de code qui le fait l'astuce vient de l'utilisation de deux séparateurs (qui ne doivent pas figurer dans le texte de base) dont la longueur totale représente avec la chaine remplacante un longueur égale à la chaine à remplacer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
              move 0 to w-tally

                inspect w-ficent1 tallying w-tally

                for all "000000;"

*         On obtient le nombre de fois que la chaine a remplacer figure

                if (w-tally > 0)

* On remplace la chaine avec une chaine de meme longueur contenant des séparateurs étranges

                perform varying w-i from 1 by 1

                until w-i > w-tally

                inspect w-ficent1 replacing 

                first

                " 000000;" by ";(@)(**)"

                unstring w-ficent1 delimited by "(**)"

                into w-prient1 w-secent1

                end-unstring

* ces séparateurs permettent de reconstituer la chaine 

                string w-prient1 delimited by "(@)"

                w-secent1 delimited by size

                into

                w-ficent1

                end-string

                end-perform

                end-if[

Le code a télécharger est relatif à la transformation d'un fichier texte pour que la séquence 000000; soit remplacé par ;

le code fonctionne sous Cobol microfocus mais à mon avis il fonctionnera sans problème sur un mainframe

Qu'en pensez-vous ?

[escartefigue]

move 0 to w-tally
inspect w-ficent1 tallying w-tally
for all "000000;"
* On obtient le nombre de fois que la chaine a remplacer figure
if (w-tally > 0)
* On remplace la chaine avec une chaine de meme longueur contenant des séparateurs étranges
perform varying w-i from 1 by 1
until w-i > w-tally
inspect w-ficent1 replacing
. . .

Une petite faute mise en couleur dans le code : test inutile puisque la condition par défaut d'un perform varying est with test before
vu que le perform vaying commence avec une valeur de 1, si w-tally vaut zéro vous n'entrez jamais dans la boucle, donc inutile de tester avant

[marc.bichara]

Ce n'est absolument pas une erreur. Le code fonctionnerait qu'on ait ou pas mis ce test...
C'est un test qui permet de clarifier le code.
On peut éventuellement argumenter par perfectionnisme que le code serait plus allégé avec cette ligne de test en moins...
Car en temps de calcul le code ne serait plus performant que dans le cas ou la chaine en question est plus fréquemment trouvée dans les chaines qu'on teste.

[escartefigue]

Ce n'est absolument pas une erreur. Le code fonctionnerait qu'on ait ou pas mis ce test...
C'est un test qui permet de clarifier le code.
On peut éventuellement argumenter par perfectionnisme que le code serait plus allégé avec cette ligne de test en moins...

Que le code fonctionne est une chose, mais une instruction redondante reste une erreur, légère certes, mais une erreur.

La maitrise du langage que l'on utilise est toujours un plus.
Il faut éviter les tests inutiles :
- cout CPU (surtout s'ils sont dans une boucle et que l'on traite des volumes significatifs)
- code alourdi inutilement au détriment de la compréhension et de la maintenance
- mauvais exemple pour les débutants, un programme est souvent recopié pour en faire d'autres, et c'est ainsi qu'on retrouve des pléthores d'erreur dans le patrimoine applicatif

Dans la même catégorie on trouve fréquemment des initialise sur une zone, préalables à un move sur la même zone.

Rendre le code plus clair est une préoccupation louable, mais en ce cas, ajoutez un commentaire, pas du code redondant

[marc.bichara]

Autant je suis d'accord à trouver absurde des initialisations inutiles et répétées autant pour le cas qui nous concerne je persiste ce n'est pas une erreur d'autant plus que si les chaines a tester ne contiennent pas la chaine à remplacer il s'agit d'une optimisation je vous l'ai signalé mais pour plus de précisions je vous donne le code objet généré ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
  
/*  Ici est l'instruction qui teste si w-tally est supérieur à 0 et qui va en fin de boucle si cela ne l'est pas (GLB.60)  */
  IF
00000416 0FB71590010000       movzx   edx,%GWA+00000190 : W-TALLY
0000041D 0FCA                 bswap   edx
0000041F C1EA10               shr     edx,10
00000422 0FBFD2               movsx   edx,dx
00000425 83FA00               cmp     edx,00
00000428 0F8EXXXXXXXX         jle     GLB.60
/*
 *  Ici commence la boucle perform  On initialise W-i
 */
--- 39 ---            PERFORM
0000042E 0FBF0538000000       movsx   eax,%COA+00000038 : +00001
00000435 83F800               cmp     eax,00
00000438 7DXX                 jge     GLB.16
0000043A F7D8                 neg     eax
0000043C                 GLB.16
00000439 02                   
0000043C 0FC8                 bswap   eax
0000043E C1E810               shr     eax,10
00000441 66A392010000         mov     %GWA+00000192,ax : W-I
00000447 EBXX                 jmp     GLB.19
/*
*   Fin Initialisation w-i 
*/

/*
 * GLB.17 est le point de retour de la boucle perform
 * Il ne s execute pas au premeir passage et consiste à incrementer w-i
 * Au premier passage on passe directement à GLB.19
 */
00000449                 GLB.17
00000449 0FB71592010000       movzx   edx,%GWA+00000192 : W-I
00000450 0FCA                 bswap   edx
00000452 C1EA10               shr     edx,10
00000455 6683C201             add     dx,01
00000459 0FBFCA               movsx   ecx,dx
0000045C 83F900               cmp     ecx,00



COBOL97 V50L10  REPCSV                                                                    MON APR 18 08:50:38 2016  0007


  ADDR     OBJECT CODE  LABEL   INSTRUCTION


0000045F 7DXX                 jge     GLB.18
00000461 F7D9                 neg     ecx
00000463                 GLB.18
00000460 02                   
00000463 0FC9                 bswap   ecx
00000465 C1E910               shr     ecx,10
00000468 66890D92010000       mov     %GWA+00000192,cx : W-I
/*
  * Debut de test pour mettre fin à la boucle perform
  */
0000046F                 GLB.19
00000448 26                   
0000046F 0FB71590010000       movzx   edx,%GWA+00000190 : W-TALLY
00000476 0FCA                 bswap   edx
00000478 C1EA10               shr     edx,10
0000047B 0FB70592010000       movzx   eax,%GWA+00000192 : W-I
00000482 0FC8                 bswap   eax
00000484 C1E810               shr     eax,10
00000487 6639D0               cmp     ax,dx
0000048A 0F8FXXXXXXXX         jg      GLB.60
/*
 * A ce niveau on va en fin de boucle (GLB.60)  la meme que celle du test w-tally >0 si w-i est supérieur à w-tally
 */
--- 41 ---            INSPECT

Donc 6 instructions qui s executent si il n'y a aucune occurence de la chaine à remplacer au lieu
de 16 instructions si on lance la boucle sans test préalable

Ainsi... pour etre tatillon et pointilliste à l'extrême et rejoindre votre état d'esprit d'optimisation, .
il vaut mieux dans le cas où il y a à tester plus de chaines sans occurence que de chaines avec occurence mettre ce test même s'il est redondant.
Pour continuer dans cet esprit je vous concède toutefois que le code est de 18 octets plus grand. Ce qui aurait eu une importance dans les années 50 ou 60 mais est négligeable par rapport aux dimensions des mémores que l'on a actuellement.

Enfin pour moi sur ce problème qui n'en est pas à mon point de vue je ne m'étenrai plus.