Les manipulations de bits en Cobol [Sources]

**Pralinor** · 19/03/2009, 13h13

Kikoo les gens,

Votre amis javaiste Jean-Robert a la bonne idée de mettre dans la super table un champ de bits concaténé constitués de tops. Et bonheur suprême, il vous faut lire ce champ pour le manipuler...
Il est couramment admis qu'en Cobol manipuler une chaine de bit, ce n'est pas possible. Et pourtant, nous allons en ces lignes relever l'impossible ^__^

J'ai crée 2 programmes permettant l'un la compression/decompression de ns octets, ainsi qu'un programme de test.

Structure du buffer d'échange :

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
           01 BUFFER.   
              05  PREMIER         pic 9.
                  88 PREMIER-APPEL value 0.
                  88 APPEL-SUIVANT value 1.   
              05  LOG             pic 9.
                  88 LOG-OFF        value 0.
                  88 LOG-ON         value 1.
              05  TYPE-COMP       pic x(13).
                  88 COMPRESSIONS   value "COMPRESSION".
                  88 DECOMPRESSIONS value "DECOMPRESSION".  
              05  OCTET           pic x.      
              05  OCTET-BIN       pic S9(4) comp.
              05  BITS.
                  10  BITS-TAB occurs 8 pic x.     
              05  RESULTAT  pic xx.

**Pralinor** · 19/03/2009, 13h14

Le programme BitTranslator, qui permet de compresser et decompresser des chaines de bits :

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
      * ---------------------------------------------------------------
      * Progamme : BITTRANSLATOR
      * Auteur   : Pralinor
      * Date     : 13 mars 2009
      *       
      * ---------------------------------------------------------------
      * FONCTIONNALITES :
      *
      *  Permet le traitement des bits en COBOL
      *  Le programme fournit 2 utilitaires :
      *   1- COMPRESSION
      *      A partir d'une chaine de bits (8 positions) compresse
      *      cette chaine pour former un octet.
      *      (exemple '01001010' devient x'4A')
      *   2- DECOMPRESSION
      *      A partir d'un octet décompresse cet octet en ses bits
      *      (exemple x'4A' devient '01001010')
      * 
      * ---------------------------------------------------------------
      * LINKAGE :
      *
      * *-------------*------*--------*---------------------------------*
      * * VARIABLE    * Type * Taille * Description                     *  
      * *-------------*------*--------*---------------------------------*
      * * PREMIER     * Bool *      1 * Premier appel de la fonction    *
      * * LOG         * Bool *      1 * Active la LOG                   *         
      * * TYPE-COMP   * Bool *     13 * Compression ou decompression    *
      * * OCTET       * Bin  *      2 * Octet                           *
      * * BITS        * Char *      8 * Chaine de bits                  *
      * * RESULTAT    * Char *      2 * retour de fonction              * 
      * *-------------*------*--------*---------------------------------*
      *     
      * --------------------------------------------------------------
      * APPEL :
      *
      *  ******APPEL pour compression
      *  * Set COMPRESSIONS  to TRUE.
      *  * Move '010101010'  to BITS. 
      *  *
      *  ******APPEL pour décompression
      *  * SET DECOMPRESSIONS to TRUE.
      *  * Move x'FD' to OCTET 
      *    
      *    CALL "BITTRANSLATOR" USING BUFFER.
      *    If RESULTATS not = "00"
      *       Go to Plantage
      *    end-if.
      *
      * --------------------------------------------------------------
      * RETOUR :
      *
      * *------*------------------------------------------------*
      * * Code * Description                                    *
      * *------*------------------------------------------------*  
      * *   00 * OK                                             *
      * *   01 * Type de fonction non reconnu                   *
      * *   02 * Chaine de bit ne contient pas que des 0 ou 1   *
      * *------*------------------------------------------------*
      *      
      * --------------------------------------------------------------
      * FICHIERS :
      *
      *  RAS
      *
      * --------------------------------------------------------------
      * LISTE DES MODULES APPELES : 
      *
      *  RAS
      *
      * --------------------------------------------------------------
      * MODIFICATIONS : 
      *  VERSION     DATE         AUTEUR   OBJET
      *
      * --------------------------------------------------------------
       IDENTIFICATION DIVISION.
        PROGRAM-ID. BitTranslator.
        AUTHOR. Pralinor.
      *---
       ENVIRONMENT DIVISION. 
        CONFIGURATION SECTION.
         SPECIAL-NAMES.
           CLASS BINAIRE IS "0" "1".  
      *---    
       DATA DIVISION.                                
        WORKING-STORAGE SECTION.
           01  POIDS.
               05  filler   pic 9(3) value 128.
               05  filler   pic 9(3) value 64.
               05  filler   pic 9(3) value 32.
               05  filler   pic 9(3) value 16.
               05  filler   pic 9(3) value 8.
               05  filler   pic 9(3) value 4.
               05  filler   pic 9(3) value 2.
               05  filler   pic 9(3) value 1.
           01  POIDS-T redefines POIDS.
               05 POIDS-TAB occurs 8 pic 999.    
      *
           01  DIVIDENDE    pic 9.
           01  RESTE        pic 999.
           01  OCTET-TEMP   pic S9(4) comp.
           01  TL           pic 99.    
           01  decomp       pic 9(3).
           
      *   
           01 MESSAGE-T.
              05  MESS01    pic x(80) value
                  "Utilitaire de traitement de bits".
              05  MESS02    pic x(80) value
                  "Log activée".
              05  MESS03    pic x(80) value
                  "Compression".
              05  MESS04    pic x(80) value
                  "Décompression".
              05  MESS05    pic x(80) value
                  "Type de traitement incorrect".
              05  MESS06    pic x(80) value
                  "Chaine de bits incorrecte".
              05  MESS07.
                  10 filler pic x(6) value 
                  "Bit : ".
                  10 MESS07-BIT pic x.
                  10 filler pic x(9) value
                  " poids : ".
                  10 MESS07-POIDS pic 999.
                  10 filler pic x(14) value
                  " Traduction : ".
                  10 MESS07-TRAD pic 999.
                  10 filler pic x(45) value spaces.
              05  MESS08.
                  10 filler pic x(8) value
                  "Octet : ".     
                  10 MESS08-OCTET pic 999.
                  10 filler pic x(9) value
                  " poids : ".
                  10 MESS08-POIDS pic 999.
                  10 filler pic x(7) value
                  " bit : ".
                  10 MESS08-BIT pic 9.
                  10 filler pic x(49) value spaces.
                  
                  
           01 MESS-LOG redefines MESSAGE-T.
              05 MESS-TAB occurs 8 pic x(80).
           01 NUM-MESS     pic 99.          
                             
        LINKAGE SECTION.
           01 BUFFER.   
              05  PREMIER         pic 9.
                  88 PREMIER-APPEL value 0.
                  88 APPEL-SUIVANT value 1.   
              05  LOG             pic 9.
                  88 LOG-OFF        value 0.
                  88 LOG-ON         value 1.
              05  TYPE-COMP       pic x(13).
                  88 COMPRESSIONS   value "COMPRESSION".
                  88 DECOMPRESSIONS value "DECOMPRESSION".  
              05  OCTET           pic x.      
              05  OCTET-BIN       pic S9(4) comp.
              05  BITS.
                  10  BITS-TAB occurs 8 pic x.     
              05  RESULTAT  pic xx.
      *---
       PROCEDURE DIVISION USING BUFFER.
       DEBUT SECTION.
      *==============
       INIT. 
           If not LOG-ON and not LOG-OFF
              set LOG-OFF to true
           end-if.
           
           If PREMIER-APPEL
              move 1 to NUM-MESS
              perform LOGUISE
              move 2 to NUM-MESS
              perform LOGUISE
              set APPEL-SUIVANT to true
           end-if.   
                                 
           If COMPRESSIONS
              perform COMPRESSION-TRT
              go to fin
           end-if. 
           
           If DECOMPRESSIONS
              perform DECOMPRESSION-TRT
              go to fin
           end-if.
           
           Move 5 to NUM-MESS.
           Perform LOGUISE.
           
           Move "01" to RESULTAT.
           
       COMPRESSION-TRT SECTION.
      *========================        
       VERIF-BITS.
           Move 3 to NUM-MESS.
           Perform LOGUISE.
      *    
           If BITS IS NOT BINAIRE
              move 6 to NUM-MESS
              perform LOGUISE
              move "02" to RESULTAT
              go to FIN-COMPRESSION
           end-if.
       
       COMPRESS.
           Move 0 to OCTET-BIN.
           Perform varying TL from 1 by 1
                    until TL > 8
              if BITS-TAB(TL) = 1
                 add POIDS-TAB (TL) to OCTET-BIN
              end-if      
    *         
              move 7 to NUM-MESS              
              move BITS-TAB(TL)   to MESS07-BIT 
              move POIDS-TAB (TL) to MESS07-POIDS 
              move OCTET-BIN      to DECOMP
              move DECOMP         to MESS07-TRAD 
              perform LOGUISE
           end-perform. 
           Move "00" to RESULTAT.   
           
       FIN-COMPRESSION. exit.
       
       DECOMPRESSION-TRT SECTION.
      *==========================   
       DECOMPRESS.
           display "decomp"
           Move 4 to NUM-MESS.
           Perform LOGUISE.
           Move OCTET-BIN to OCTET-TEMP.
      *    
           Perform varying TL from 1 by 1
                 until TL > 8
              move octet-temp to decomp 
              divide OCTET-TEMP by POIDS-TAB (TL)
                  giving DIVIDENDE
                  remainder RESTE
              display decomp " : " DIVIDENDE " : " RESTE    
              move DIVIDENDE to BITS-TAB(TL)              
              move RESTE to OCTET-TEMP
      *
             move 8 to NUM-MESS
             move OCTET-TEMP     to MESS08-OCTET 
             move POIDS-TAB (TL) to MESS08-POIDS 
             move DIVIDENDE      to MESS08-BIT   
             perform LOGUISE
           end-perform.
           Move "00" to RESULTAT.
           
       FIN-DECOMPRESSION-TRT. exit. 
           
       FIN SECTION.
      *============     
           goback.
           
       LOGUISE SECTION.
      *================
       ECRITURE-LOG.
          If LOG-ON
             display MESS-TAB(NUM-MESS)
          end-if.   
          If PREMIER-APPEL AND LOG-OFF
             display MESS-TAB(NUM-MESS)
          end-if.   
          
       FIN-LOGUISE. exit.

NB : Programme écrit en Cobol 2 le plus puriste possible, il doit donc pouvoir passer sur n'importe quel compilateur.
A noter que j'ai utilisé du Comp pour l'octet, si cela s'avère un problème, on peut le remplacer par du Binary, ce qui devrait régler le problème.

**Pralinor** · 19/03/2009, 13h15

Et un programme de test, montrant comment faire les accès :

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
      * ---------------------------------------------------------------
      * Progamme : BITTEST
      * Auteur   : Pralinor
      * Date     : 13 mars 2009
      *       
      * ---------------------------------------------------------------
      * FONCTIONNALITES :
      *
      *  Permet de tester l'appel à BitTranslator
      * 
      * ---------------------------------------------------------------
      * LINKAGE :
      *
      * *-------------*------*--------*---------------------------------*
      * * VARIABLE    * Type * Taille * Description                     *  
      * *-------------*------*--------*---------------------------------*
      * * PREMIER     * Bool *      1 * Premier appel de la fonction    *
      * * LOG         * Bool *      1 * Active la LOG                   *         
      * * TYPE-COMP   * Bool *     13 * Compression ou decompression    *
      * * OCTET       * Bin  *      2 * Octet                           *
      * * BITS        * Char *      8 * Chaine de bits                  *
      * * RESULTATS   * Char *      2 * retour de fonction              * 
      * *-------------*------*--------*---------------------------------*
      *     
      * --------------------------------------------------------------
      * APPEL :
      *
      *   RAS
      *
      * --------------------------------------------------------------
      * RETOUR :
      *
      *   RAS
      *     
      * --------------------------------------------------------------
      * FICHIER ENTREE :
      *
      * *-------------*------*--------*-------------------------------------------*
      * * VARIABLE    * Type * Taille * Description                               *  
      * *-------------*------*--------*-------------------------------------------*
      * * FILLER      * Char *     10 * Filler                                    *
      * * TYPE-ACC    * Char *      1 * Type acces (Compression/Decompression)    *         
      * * COM-E       * Bin  *      2 * Octet à décrompresser                     *
      * * DEC-E       * Char *      8 * Chaine de bits à compresser               *
      * * FILLER      * Char *     10 * Filler                                    *
      * *-------------*------*--------*-------------------------------------------*
      *
      * --------------------------------------------------------------
      * LISTE DES MODULES APPELES : 
      *
      *  RAS
      *
      * --------------------------------------------------------------
      * MODIFICATIONS : 
      *  VERSION     DATE         AUTEUR   OBJET
      *
      * --------------------------------------------------------------
       IDENTIFICATION DIVISION.
        PROGRAM-ID. BITTEST.
        AUTHOR. Pralinor.
      *---
       ENVIRONMENT DIVISION. 
        INPUT-OUTPUT SECTION.
         FILE-CONTROL.
           SELECT Entree assign to 'FE'
              ORGANIZATION IS LINE SEQUENTIAL.
           SELECT Sortie assign to 'FS'
              ORGANIZATION IS LINE SEQUENTIAL.
      *---    
       DATA DIVISION.
        FILE SECTION. 
          FD Entree.
           01  Entree-ENR.
               05 filler    pic x(10).
               05 TYPE-ACC  pic x(1).
               05 COM-E     pic s9(4) comp.
               05 DEC-E     pic x(8).
               05 filler    pic x(10).
          FD Sortie.
           01  Sortie-ENR.
               05 filler    pic x(2).
               05 COM-S     pic S9(4) comp.
               05 DEC-S     pic x(8).
               05 filler    pic x(10).
        WORKING-STORAGE SECTION.
           01 BUFFER.   
              05  PREMIER         pic 9.
                  88 PREMIER-APPEL value 0.
                  88 APPEL-SUIVANT value 1.   
              05  LOG             pic 9.
                  88 LOG-OFF        value 0.
                  88 LOG-ON         value 1.
              05  TYPE-COMP       pic x(13).
                  88 COMPRESSIONS   value "COMPRESSION".
                  88 DECOMPRESSIONS value "DECOMPRESSION".  
              05  OCTET           pic x.      
              05  OCTET-BIN       pic S9(4) comp.
              05  BITS.
                  10  BITS-TAB occurs 8 pic x.     
              05  RESULTAT  pic xx.
          01 decomp pic 9(8).    
      *---
       PROCEDURE DIVISION.
       DEBUT SECTION.
      *==============
       Fichier.
           open input ENTREE.
           Open output SORTIE.           
           Initialize BUFFER.
           
           Perform TRAITEMENT.
           Perform FIN.
           
       TRAITEMENT SECTION.
      *===================     
       LECTURE-FICHIER.
           Read Entree
                at end go to FIN-TRAITEMENT.
      *          
       VERIFIE-TYPE-TRAITEMENT.
           If TYPE-ACC = "C"
              go to TRT-COMPRESS
           end-if.
                      
           If TYPE-ACC = "D"
              go to TRT-DECOMPRESS
           end-if.
           
           Go to LECTURE-FICHIER.
      *  ******APPEL pour compression           
       TRT-COMPRESS.                    
           set LOG-ON        to true.
           Set COMPRESSIONS  to TRUE.
           Move DEC-E        to BITS.
           
           CALL "BitTranslator" USING BUFFER.
           If RESULTAT not = "00"
              display "erreur"
           end-if.
           Move OCTET-BIN to COM-S.
           Go to ECRITURE.
      *   
      *  ******APPEL pour décompression
       TRT-DECOMPRESS.          
           set LOG-ON         to true.
           SET DECOMPRESSIONS to TRUE.
           Move COM-E         to OCTET-BIN. 
           move com-e to decomp.
           display decomp.
           
           CALL "BitTranslator" USING BUFFER.
           If RESULTAT not = "00"
              display "erreur"
           end-if.
           Move BITS to DEC-S.
           Go to ECRITURE.
                      
       ECRITURE.    
           Write SORTIE-ENR.
           Go to LECTURE-FICHIER.
        
       FIN-TRAITEMENT. Exit.
       
       FIN SECTION.
      *============
       FIN-PORG. 
           stop run.

**Pralinor** · 19/03/2009, 13h15

Fichier de test :

Code :

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

1
2
3
4
5
6
7
8
1234567890D  --------         
1234567890D ÿ--------         
1234567890D --------         
1234567890D --------         
1234567890C  00000000         
1234567890C  01001001         
1234567890C  10001111         
1234567890C  11111111

Permet de décompresser '00', 'FF', '05' et '0B' ou compresser les chaines visibles.

**Pralinor** · 19/03/2009, 13h24

J'ai inclus un système de log (qui part sur la sortie standard via les 'display').
Pour activer la log, il suffit de faire un

Code :

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

SET LOG-ON to true.

Avant l'appel au programme BitTranslator.

Il également possible de se créer 2 petits sous-programmes BitCompress et Bit Decompress appelant BitTranslator (ce qui peut être plus simple à la compréhension) :

Code :

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

1
2
3
Set LOG-OFF to true.
Move MaChaine to Chaine-Bits.
Call BitCompress using buffer-compress.

Voili voilu

**Homer-ac** · 30/03/2009, 23h54

C'est un moyen. Il y en a d'autres, dont celui qui a ma préférence et qui est de simplement utiliser un tableau des 256 valeurs possibles en binaire. Pas de calcul, 3 instuctions. On fait simplement +1 sur l'indice binary représentant l'octet à rechercher pour pointer directement sur le poste qui correspond à sa valeur en format Display sur 8 octets. Le risque est bien entendu de se planter pour une de ces valeurs. J'ai un COBOL qui utilise ça mais qui valide tout le tableau quand on active le mode debug via la routine de service Langage Environnement 'CEESITST', qui permet de faire très facilement en COBOL MVS des tests sur le positionnement de chaque bit dans un mot. Les valeurs binaires en question sont donc vérifiées, fiables et très simples à utiliser en accès indiciel direct.

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
          05 TABLEAU-BINAIRE.
             10 Pic x(08)  Value '00000000'.
             10 Pic x(08)  Value '00000001'.
             10 Pic x(08)  Value '00000010'.
             10 Pic x(08)  Value '00000011'.
             10 Pic x(08)  Value '00000100'.
             10 Pic x(08)  Value '00000101'.
             10 Pic x(08)  Value '00000110'.
             10 Pic x(08)  Value '00000111'.
             10 Pic x(08)  Value '00001000'.
             10 Pic x(08)  Value '00001001'.
             10 Pic x(08)  Value '00001010'.
             10 Pic x(08)  Value '00001011'.
             10 Pic x(08)  Value '00001100'.
             10 Pic x(08)  Value '00001101'.
             10 Pic x(08)  Value '00001110'.
             10 Pic x(08)  Value '00001111'.
             10 Pic x(08)  Value '00010000'.
             10 Pic x(08)  Value '00010001'.
             10 Pic x(08)  Value '00010010'.
             10 Pic x(08)  Value '00010011'.
             10 Pic x(08)  Value '00010100'.
             10 Pic x(08)  Value '00010101'.
             10 Pic x(08)  Value '00010110'.
             10 Pic x(08)  Value '00010111'.
             10 Pic x(08)  Value '00011000'.
             10 Pic x(08)  Value '00011001'.
             10 Pic x(08)  Value '00011010'.
             10 Pic x(08)  Value '00011011'.
             10 Pic x(08)  Value '00011100'.
             10 Pic x(08)  Value '00011101'.
             10 Pic x(08)  Value '00011110'.
             10 Pic x(08)  Value '00011111'.
             10 Pic x(08)  Value '00100000'.
             10 Pic x(08)  Value '00100001'.
             10 Pic x(08)  Value '00100010'.
             10 Pic x(08)  Value '00100011'.
             10 Pic x(08)  Value '00100100'.
             10 Pic x(08)  Value '00100101'.
             10 Pic x(08)  Value '00100110'.
             10 Pic x(08)  Value '00100111'.
             10 Pic x(08)  Value '00101000'.
             10 Pic x(08)  Value '00101001'.
             10 Pic x(08)  Value '00101010'.
             10 Pic x(08)  Value '00101011'.
             10 Pic x(08)  Value '00101100'.
             10 Pic x(08)  Value '00101101'.
             10 Pic x(08)  Value '00101110'.
             10 Pic x(08)  Value '00101111'.
             10 Pic x(08)  Value '00110000'.
             10 Pic x(08)  Value '00110001'.
             10 Pic x(08)  Value '00110010'.
             10 Pic x(08)  Value '00110011'.
             10 Pic x(08)  Value '00110100'.
             10 Pic x(08)  Value '00110101'.
             10 Pic x(08)  Value '00110110'.
             10 Pic x(08)  Value '00110111'.
             10 Pic x(08)  Value '00111000'.
             10 Pic x(08)  Value '00111001'.
             10 Pic x(08)  Value '00111010'.
             10 Pic x(08)  Value '00111011'.
             10 Pic x(08)  Value '00111100'.
             10 Pic x(08)  Value '00111101'.
             10 Pic x(08)  Value '00111110'.
             10 Pic x(08)  Value '00111111'.
             10 Pic x(08)  Value '01000000'.
             10 Pic x(08)  Value '01000001'.
             10 Pic x(08)  Value '01000010'.
             10 Pic x(08)  Value '01000011'.
             10 Pic x(08)  Value '01000100'.
             10 Pic x(08)  Value '01000101'.
             10 Pic x(08)  Value '01000110'.
             10 Pic x(08)  Value '01000111'.
             10 Pic x(08)  Value '01001000'.
             10 Pic x(08)  Value '01001001'.
             10 Pic x(08)  Value '01001010'.
             10 Pic x(08)  Value '01001011'.
             10 Pic x(08)  Value '01001100'.
             10 Pic x(08)  Value '01001101'.
             10 Pic x(08)  Value '01001110'.
             10 Pic x(08)  Value '01001111'.
             10 Pic x(08)  Value '01010000'.
             10 Pic x(08)  Value '01010001'.
             10 Pic x(08)  Value '01010010'.
             10 Pic x(08)  Value '01010011'.
             10 Pic x(08)  Value '01010100'.
             10 Pic x(08)  Value '01010101'.
             10 Pic x(08)  Value '01010110'.
             10 Pic x(08)  Value '01010111'.
             10 Pic x(08)  Value '01011000'.
             10 Pic x(08)  Value '01011001'.
             10 Pic x(08)  Value '01011010'.
             10 Pic x(08)  Value '01011011'.
             10 Pic x(08)  Value '01011100'.
             10 Pic x(08)  Value '01011101'.
             10 Pic x(08)  Value '01011110'.
             10 Pic x(08)  Value '01011111'.
             10 Pic x(08)  Value '01100000'.
             10 Pic x(08)  Value '01100001'.
             10 Pic x(08)  Value '01100010'.
             10 Pic x(08)  Value '01100011'.
             10 Pic x(08)  Value '01100100'.
             10 Pic x(08)  Value '01100101'.
             10 Pic x(08)  Value '01100110'.
             10 Pic x(08)  Value '01100111'.
             10 Pic x(08)  Value '01101000'.
             10 Pic x(08)  Value '01101001'.
             10 Pic x(08)  Value '01101010'.
             10 Pic x(08)  Value '01101011'.
             10 Pic x(08)  Value '01101100'.
             10 Pic x(08)  Value '01101101'.
             10 Pic x(08)  Value '01101110'.
             10 Pic x(08)  Value '01101111'.
             10 Pic x(08)  Value '01110000'.
             10 Pic x(08)  Value '01110001'.
             10 Pic x(08)  Value '01110010'.
             10 Pic x(08)  Value '01110011'.
             10 Pic x(08)  Value '01110100'.
             10 Pic x(08)  Value '01110101'.
             10 Pic x(08)  Value '01110110'.
             10 Pic x(08)  Value '01110111'.
             10 Pic x(08)  Value '01111000'.
             10 Pic x(08)  Value '01111001'.
             10 Pic x(08)  Value '01111010'.
             10 Pic x(08)  Value '01111011'.
             10 Pic x(08)  Value '01111100'.
             10 Pic x(08)  Value '01111101'.
             10 Pic x(08)  Value '01111110'.
             10 Pic x(08)  Value '01111111'.
             10 Pic x(08)  Value '10000000'.
             10 Pic x(08)  Value '10000001'.
             10 Pic x(08)  Value '10000010'.
             10 Pic x(08)  Value '10000011'.
             10 Pic x(08)  Value '10000100'.
             10 Pic x(08)  Value '10000101'.
             10 Pic x(08)  Value '10000110'.
             10 Pic x(08)  Value '10000111'.
             10 Pic x(08)  Value '10001000'.
             10 Pic x(08)  Value '10001001'.
             10 Pic x(08)  Value '10001010'.
             10 Pic x(08)  Value '10001011'.
             10 Pic x(08)  Value '10001100'.
             10 Pic x(08)  Value '10001101'.
             10 Pic x(08)  Value '10001110'.
             10 Pic x(08)  Value '10001111'.
             10 Pic x(08)  Value '10010000'.
             10 Pic x(08)  Value '10010001'.
             10 Pic x(08)  Value '10010010'.
             10 Pic x(08)  Value '10010011'.
             10 Pic x(08)  Value '10010100'.
             10 Pic x(08)  Value '10010101'.
             10 Pic x(08)  Value '10010110'.
             10 Pic x(08)  Value '10010111'.
             10 Pic x(08)  Value '10011000'.
             10 Pic x(08)  Value '10011001'.
             10 Pic x(08)  Value '10011010'.
             10 Pic x(08)  Value '10011011'.
             10 Pic x(08)  Value '10011100'.
             10 Pic x(08)  Value '10011101'.
             10 Pic x(08)  Value '10011110'.
             10 Pic x(08)  Value '10011111'.
             10 Pic x(08)  Value '10100000'.
             10 Pic x(08)  Value '10100001'.
             10 Pic x(08)  Value '10100010'.
             10 Pic x(08)  Value '10100011'.
             10 Pic x(08)  Value '10100100'.
             10 Pic x(08)  Value '10100101'.
             10 Pic x(08)  Value '10100110'.
             10 Pic x(08)  Value '10100111'.
             10 Pic x(08)  Value '10101000'.
             10 Pic x(08)  Value '10101001'.
             10 Pic x(08)  Value '10101010'.
             10 Pic x(08)  Value '10101011'.
             10 Pic x(08)  Value '10101100'.
             10 Pic x(08)  Value '10101101'.
             10 Pic x(08)  Value '10101110'.
             10 Pic x(08)  Value '10101111'.
             10 Pic x(08)  Value '10110000'.
             10 Pic x(08)  Value '10110001'.
             10 Pic x(08)  Value '10110010'.
             10 Pic x(08)  Value '10110011'.
             10 Pic x(08)  Value '10110100'.
             10 Pic x(08)  Value '10110101'.
             10 Pic x(08)  Value '10110110'.
             10 Pic x(08)  Value '10110111'.
             10 Pic x(08)  Value '10111000'.
             10 Pic x(08)  Value '10111001'.
             10 Pic x(08)  Value '10111010'.
             10 Pic x(08)  Value '10111011'.
             10 Pic x(08)  Value '10111100'.
             10 Pic x(08)  Value '10111101'.
             10 Pic x(08)  Value '10111110'.
             10 Pic x(08)  Value '10111111'.
             10 Pic x(08)  Value '11000000'.
             10 Pic x(08)  Value '11000001'.
             10 Pic x(08)  Value '11000010'.
             10 Pic x(08)  Value '11000011'.
             10 Pic x(08)  Value '11000100'.
             10 Pic x(08)  Value '11000101'.
             10 Pic x(08)  Value '11000110'.
             10 Pic x(08)  Value '11000111'.
             10 Pic x(08)  Value '11001000'.
             10 Pic x(08)  Value '11001001'.
             10 Pic x(08)  Value '11001010'.
             10 Pic x(08)  Value '11001011'.
             10 Pic x(08)  Value '11001100'.
             10 Pic x(08)  Value '11001101'.
             10 Pic x(08)  Value '11001110'.
             10 Pic x(08)  Value '11001111'.
             10 Pic x(08)  Value '11010000'.
             10 Pic x(08)  Value '11010001'.
             10 Pic x(08)  Value '11010010'.
             10 Pic x(08)  Value '11010011'.
             10 Pic x(08)  Value '11010100'.
             10 Pic x(08)  Value '11010101'.
             10 Pic x(08)  Value '11010110'.
             10 Pic x(08)  Value '11010111'.
             10 Pic x(08)  Value '11011000'.
             10 Pic x(08)  Value '11011001'.
             10 Pic x(08)  Value '11011010'.
             10 Pic x(08)  Value '11011011'.
             10 Pic x(08)  Value '11011100'.
             10 Pic x(08)  Value '11011101'.
             10 Pic x(08)  Value '11011110'.
             10 Pic x(08)  Value '11011111'.
             10 Pic x(08)  Value '11100000'.
             10 Pic x(08)  Value '11100001'.
             10 Pic x(08)  Value '11100010'.
             10 Pic x(08)  Value '11100011'.
             10 Pic x(08)  Value '11100100'.
             10 Pic x(08)  Value '11100101'.
             10 Pic x(08)  Value '11100110'.
             10 Pic x(08)  Value '11100111'.
             10 Pic x(08)  Value '11101000'.
             10 Pic x(08)  Value '11101001'.
             10 Pic x(08)  Value '11101010'.
             10 Pic x(08)  Value '11101011'.
             10 Pic x(08)  Value '11101100'.
             10 Pic x(08)  Value '11101101'.
             10 Pic x(08)  Value '11101110'.
             10 Pic x(08)  Value '11101111'.
             10 Pic x(08)  Value '11110000'.
             10 Pic x(08)  Value '11110001'.
             10 Pic x(08)  Value '11110010'.
             10 Pic x(08)  Value '11110011'.
             10 Pic x(08)  Value '11110100'.
             10 Pic x(08)  Value '11110101'.
             10 Pic x(08)  Value '11110110'.
             10 Pic x(08)  Value '11110111'.
             10 Pic x(08)  Value '11111000'.
             10 Pic x(08)  Value '11111001'.
             10 Pic x(08)  Value '11111010'.
             10 Pic x(08)  Value '11111011'.
             10 Pic x(08)  Value '11111100'.
             10 Pic x(08)  Value '11111101'.
             10 Pic x(08)  Value '11111110'.
             10 Pic x(08)  Value '11111111'.

          05 TABLEAU-BIN-I       Redefines TABLEAU-BINAIRE
                                 Pic x(8) Occurs 256.

**Pralinor** · 31/03/2009, 10h01

Tout a fait c'est un autre moyen, mais moins pratique si jamais tu dois travailler sur 2 octets voire 4. Et découper les octets en sous octets ce n'est pas une sinécure. A l'origine j'avais écrit le tuto sur 4 octets, mais ça n'aidait pas la compréhension, j'ai limité à 1 octet. C'est pas difficile au besoin de le porter sur 4.
J'avoue avoir un instant hésité à montrer une technique par tableau (celle que tu emploies) ou par découpage demi-octet.

**Homer-ac** · 02/04/2009, 00h39

Hum, j'ai hésité avant de répondre, un forum n'est pas un lieu polémique mais de diffusion d'informations.
J'ai déjà eu ce problème de gestion pour retrouver les options de compilations de tous les COBOL présents dans des LOADLIB MVS. Dans ce cas, parce qu'il y a du monde, un seul critère, la performance. On analyse un grand nombre de load qui comportent chacun une série de 4 à 5 octets dont chaque bit représente une option de compilation. La solution d'une table prédéfinie donne un résultat direct et plus rapide que toute autre pour alimenter un tableau de 40 valeurs '0' ou '1' par programme, chacune représentative d'une option de compilation que l'on peut associer avec un tableau d'équivalence en clair.
Je persiste, il n'y a pas plus simple et rapide. En entrée une somme d'octets quelconque, en sortie une bitmap en étendu de chacun des octets, soit 8X le nombre d'octets en entrée. La gestion par tableau génère un minimum d'instructions, c'est de l'accès direct. Le seul risque par rapport à un calcul est d'entrer une valeur erronnée. Il suffit de prévoir une routine de contrôle activable ponctuellement. Pour ça une routine Language Environnement s'utilise facilement et sans risque d'erreur en MVS.

Les manipulations de bits en Cobol [Sources]

Contribuez

Discussions similaires

Partager

Partager