Convert = c3 = b6 à Ö supposant UTF-8

quelque chose pour obtenir OP a commencé.

Analysez la chaîne "= c3 = b6" code>, à la recherche de 2 octets comme des caractères hexadécimaux. Ensuite, formez une chaîne à imprimer (et espoir printf code> interprétera sous UTF-8) - complétants conformes à printf ("% s", ...) code> n'ont "pas de spécial Les dispositions sont faites pour les personnages multibytes ». YMMV . P>

=C3=B6
1 ö
2 ö
3 ö

Décodage COSTED-IMPIABLE Strings implique trois choses:

• ignorer les nouvelles lignes douces. Ce sont = code> suivi d'une nouvelle ligne. P> li>

• convert = code> suivi de deux chiffres hexadécimaux, au caractère dont le code correspond à cette valeur hexadécimale p> li> ul>

  Il existe trois approches principales pour décoder des données: p>

  1. filtre d'entrée. Au lieu d'E.G. fgetc () code>, vous utilisez une fonction qui lit et décode l'entrée imprimable citée. p> li>

  2. conversion vers un nouveau tampon. Voir la Convert () Code> Fonction dans Craig Esteys Répondez à cette même question. P> li>

  3. conversion en place. Ceci est possible, car chaque chaîne valide imprimable-imprimable indiquée est au moins aussi longue que le même décodé. P> li> ol>

     ---

     filtre d'entrée. Pour la simplicité, regardons un caractère à la fois. (Notez que de nombreux caractères UTF-8 sont plus longs qu'un char.) P>

     Premièrement, nous avons besoin d'une fonction d'assistance pour convertir des caractères hexadécimaux à leurs valeurs arithmétiques respectives: P>

     size_t  decode_quoted_printable(char *dst, const char *src)
     {
         const char *const origin = dst;
     
         /* Neither pointer may be NULL. src == dst is okay, however. */
         if (!dst || !src) {
             errno = EINVAL;
             return 0;
         }
     
         /* Copy loop. */
         while (*src)
             if (*src == '=') {
                 if (src[1] == '\0') {
                     /* '=' at the end of string. Skipped. */
                     break;
                 } else
                 if (src[1] == '\n') {
                     /* Soft newline. Skip both =\n and =\n\r newlines. */
                     if (src[2] == '\r')
                         src += 3;
                     else
                         src += 2;
                 } else
                 if (src[1] == '\r') {
                     /* Soft newline. Skip both =\r and =\r\n newlines. */
                     if (src[2] == '\n')
                         src += 3;
                     else
                         src += 2;
                 } else {
                     const int  hi = hex_digit((unsigned char)(src[1]));
                     const int  lo = hex_digit((unsigned char)(src[2]));
                     if (hi >= 0 && lo >= 0) {
                         *(dst++) = lo + 16*hi;
                         src += 3;
                     } else {
                         /* Error in input format. We are permissive,
                            and reproduce the erroneous `=XY` as-is. */
                         *(dst++) = *(src++);
                     }
                 }
             } else
             if (*src == '\n') {
                 if (src[1] == '\r')
                     src += 2;
                 else
                     src += 1;
                 *(dst++) = '\n';
             } else
             if (*src == '\r') {
                 if (src[1] == '\n')
                     src += 2;
                 else
                     src += 1;
                 *(dst++) = '\n';
             } else
                *(dst++) = *(src++);
     
         /* Terminate result to make it a string. */
         *dst = '\0';
     
         /* Just in case the source was an empty string, we clear
            errno to zero.  This also means we always set errno,
            which is a bit rare, but makes the use of this function
            easy: errno is nonzero iff there was an error. */
         errno = 0;
         return (size_t)(dst - origin);
     }