**********************************************************************
      *                                                                    *
      *  Codification BASE64 d'une chaine en RPG.                          *
      *   (par exemple 'volubis' devient 'pZaTpIKJog==')                   *
      *                                                                    *
      *   en V7, SF99701 level 23 propose aussi SYSTOOLS.BASE64Encode)     *
      *                                                                    *
      **********************************************************************
     Dptr7             S               *
     Dascii7           DS             3    based(ptr7)
     D C1                             1
     D C2                             1
     D C3                             1
 
     Dptr64            S               *
     Dbase64           DS             4    based(ptr64)
     D b1                             1
     D b2                             1
     D b3                             1
     D b4                             1
 
     Dbinasciic        DS
     D binascii                       3u 0 inz
     D binbase64       S              3u 0
 
     d boucle          S             10I 0
     d boucler         S             10I 0
     d b               S             10I 0
     D nbyte           S             10U 0 Inz(57)
     Dcode64           S              1    dim(64) ctdata perrcd(64)
     D reste           S              5I 0
     D wtemp           S              5I 0
     D bufferI         S             57A
     D bufferO         S             78A
 
     C     *entry        plist
     C                   parm                    BufferI
     C                   parm                    BufferO
      //
      // BASE64 , utilisé à l'origine pour les pièces attachées de mail
      //          chaque ligne doit être composée de 76 C maxi
      //          et ce pour chaque série de 57c en entrée
      //           puisque il faut tranformer chaque groupe de 3c
      //                                           en série de 4c.

      //
      /FREE
       ptr7  = %addr(BufferI);
       ptr64 = %addr(BufferO);
 
       nbyte = %len(%trimr(BuFferI));
       boucle = %div(nbyte : 3);
       boucler = %rem(nbyte : 3);
       if boucler > 0;
         boucle = boucle + 1;
       endif;
 
       for B = 1 to boucle;
         exsr SRbase64;
         ptr7  = ptr7 + 3;
         ptr64 = ptr64 + 4;
       endfor;
       *inLR = *on;
       //
       // On passe un groupe de trois caractères en quatres caractères base 64
       //
       //
       //  Exemple soit "GIF" en ascii
       //
       //               ==> x'717370'
       //
       //               ==> ! 01 00 01 11 ! 01 00 10 01 ! 01 00 01 10 !
       //                   -------------------------------------------
       //
       //  il faut générer     x'17'       x'52'      x'37'      x'06'
       //                   ! 01 00 01 ! 11 01 00 ! 10 01 01 ! 00 01 10 !
       //                   ---------------------------------------------
       //
       //  c'est à dire  (chaque octet physique faisant toujours 8 bits)
       //
       //            ! 00 01 00 01 ! 00 11 01 00 ! 00 10 01 01 ! 00 01 10 !
       //            ------------------------------------------------------
       //
       //  pour cela soit "GIF" = C1C2C3 et il faut produire B1B2B3B4
       //
       //   c1  / 4    =  b1 (01 00 01) reste 11
       //
       //   reste X 16 =  w  (11 00 00)
       //   c2  / 16   =  b2 (   01 00)    reste 10 01

       //   b2 + w     =  b2 (11 01 00)
       //
       //   reste X  4  = w  (10 01 00)
       //   c3  / 64    = b3 (      01)    reste 00 01 10
       //   b3 + w      = b3 (10 01 01)
       //   b4          = reste
       //
       //
       //
       begsr SRbase64;
         // 1er octet base 64 = bits 123456 du 1er caractère
         binasciic = C1;
         binbase64 = %div(binascii : 4);
         reste = %rem(binascii : 4);
         b1 = code64(binbase64 + 1);
         // 2è octet base 64 =  bits 78 du 1er caractère et reste à 0
         //  si dernier groupe = 1 octet
         wtemp = reste * 16;
         if b = boucle and boucler = 1;
              binbase64 = wtemp;
              b2 = code64(binbase64 + 1);
              b3 = '=';
              b4 = '=';
         else;
           // sinon
           // 2è octet base 64 =  bits 78 du 1er caractère et 1234 du 2è
           binasciic = C2;
           binbase64 = %div(binascii : 16);
           reste = %rem(binascii : 16);
           binbase64 += wtemp;
           b2 = code64(binbase64 + 1);
           // 3è octet base 64 =  bits 5678 du 1er caractère et reste à 0
           //  si dernier groupe = 2 octets
           wtemp = reste * 4;
           if b = boucle and boucler = 2;
             binbase64 = wtemp;
             b3 = code64(binbase64 + 1);
             b4 = '=';
           else;
             // 3è octet base 64 =  bits 5678 du 2è caractère et 12 du 3è
             binasciic = C3;
             binbase64 = %div(binascii : 64);
             reste = %rem(binascii : 64);
             binbase64 += wtemp;

             b3 = code64(binbase64 + 1);
             // 4è octet base 64 =  bits 345678 du 3è
             b4 = code64(reste + 1);
           endif;
         endif;
       endsr;
      /END-FREE
**
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/