Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Contribuez Discussion :

Les manipulations de bits en Cobol


Sujet :

Contribuez

  1. #1
    Membre à l'essai
    Les manipulations de bits en Cobol
    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.

  2. #2
    Membre à l'essai
    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.

  3. #3
    Membre à l'essai
    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.

  4. #4
    Membre à l'essai
    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.

  5. #5
    Membre à l'essai
    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

    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

  6. #6
    Membre confirmé
    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.

  7. #7
    Membre à l'essai
    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.

  8. #8
    Membre confirmé
    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.

###raw>template_hook.ano_emploi###