Termine (éventuellement) une chaîne multi-octets?

Question

Je travaille sur un code C et j'ai du mal à trouver un moyen de terminer une chaîne après un certain nombre de caractères. Par exemple, je dois terminer la chaîne data après 3 caractères. Si c'est une chaîne ASCII, je peux faire quelque chose comme

data[3] = 0; 

Mais dans mon cas, l'un des personnages pourrait être multi-octets comme E ou A. Quel serait le meilleur moyen de terminer une telle chaîne après un nombre donné de caractères?

MISE À JOUR:

En gros:

char s_mon[7]; 

setlocale(LC_ALL, ""); 
strftime(s_mon, 7, "%b", tick_time); 

locale actuelle est le français. Le mois est stocké comme "févr". Besoin d'être "fév", mais cela doit être universel, donc des entrées comme "mars" pourraient aussi être coupées en 3 caractères.

Answer 1

Terminé en réutilisant cette fonction utf_str_to_upper. La fonction traite correctement les valeurs multi-octets. Il convertit également la chaîne en majuscules (dont j'avais également besoin) mais cette fonctionnalité peut être supprimée si nécessaire.

La seule modification que j'ai faite est de passer le deuxième paramètre limit qui est limite en caractères à laquelle j'ai besoin de couper la chaîne. La fonction insère alors le terminateur à la position correcte de l'octet et renvoie la position de l'octet. Voici le code complet:

uint8_t utf8_str_to_upper(char* s, uint8_t limit) { 

    uint8_t char_no = 0; 
    uint8_t* p; 

    for (p = (uint8_t*)s; *p; ++p) { 

     // (<128) ascii character 
     // U+00000000 – U+0000007F: 0xxxxxxx 
     if (*p < 0b10000000) { 
      if (*p >= 0x61 && *p <= 0x7A) { 
       *p = *p - 0x20; // a~z -> A~Z 
      } 

     // (<192) unexpected continuation byte 
     } else if (*p < 0b11000000) { 

     // (<224) 2 byte sequence 
     // U+00000080 – U+000007FF: 110xxxxx 10xxxxxx 
     } else if (*p < 0b11100000) { 
      uint16_t code = ((uint16_t)(p[0] & 0b00011111) << 6) | (p[1] & 0b00111111); 
      if (
       (code >= 0x00E0 && code <= 0x00F6) || // à~ö -> À~Ö 
       (code >= 0x00F8 && code <= 0x00FE) // ø~þ -> Ø~Þ 
      ) { 
       code -= 0x0020; 
       p[0] = 0b11000000 | ((code >> 6) & 0b00011111); 
       p[1] = 0b10000000 | (code  & 0b00111111); 
      } 
      ++p; 

     // (<240) 3 byte sequence 
     // U+00000800 – U+0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx 
     } else if (*p < 0b11110000) { 
      p += 2; 

     // (<248) 4 byte sequence 
     // U+00010000 – U+001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 
     } else if (*p < 0b11111000) { 
      p += 3; 

     // (<252) 5 byte sequence 
     // U+00200000 – U+03FFFFFF: 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 
     } else if (*p < 0b11111100) { 
      p += 4; 

     // (<254) 6 byte sequence 
     // U+04000000 – U+7FFFFFFF: 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 
     } else if (*p < 0b11111110) { 
      p += 5; 
     } 

     if (limit) { 
      char_no++; 

      if (char_no == limit) { 
       *(p + 1) = 0; 
       return p-(uint8_t*)s + 1; 
       break; 
      } 

     } 

    } 

    return p-(uint8_t*)s + 1; 
}