Remplacer chaine par une chaine de longueur différente

Présentation
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.


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
Détails
Catégories : Codes sources Cobol
Avatar de marc.bichara
Membre régulier
Voir tous les téléchargements de l'auteur
Licence : Autre
Date de mise en ligne : 6 avril 2016




Avatar de escartefigue escartefigue - Expert éminent https://www.developpez.com
le 15/04/2016 à 16:21
Citation Envoyé par marc.bichara  Voir le message


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
Avatar de marc.bichara marc.bichara - Membre régulier https://www.developpez.com
le 16/04/2016 à 15:56
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.
Avatar de escartefigue escartefigue - Expert éminent https://www.developpez.com
le 17/04/2016 à 14:43
Citation Envoyé par marc.bichara  Voir le message
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
Avatar de marc.bichara marc.bichara - Membre régulier https://www.developpez.com
le 18/04/2016 à 13:04
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
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.
Developpez.com décline toute responsabilité quant à l'utilisation des différents éléments téléchargés.
Contacter le responsable de la rubrique Accueil