Comment un fichier avec des caractères Chinois connaître le nombre d'octets à utiliser par caractère?

Tout cela fait partie de l'encodage UTF8 (qui n'est qu'un schéma de codage d'Unicode).

La taille peut compris en examinant le premier octet comme suit:

• si elle commence avec motif de bits "10" (0x80-0xbf), ce n'est pas le premier octet d'une séquence et vous devez sauvegarder jusqu'à ce que vous trouver le début, toutes les octets qui commence par "0" ou "11" (merci à Jeffrey Hantin de remarquer que dans les commentaires).
• si elle commence avec motif de bits "0" (0x00-0x7f), il est de 1 octet.
• si elle commence avec motif de bits "110" (0xc0-0xdf), c'est de 2 octets.
• si elle commence avec motif de bits "1110" (0xe0-0xef), c'est 3 octets.
• si elle commence avec motif de bits "11110" (0xf0-0xf7), c'est 4 octets.

Je vais dupliquer le tableau, mais l'original est sur la Wikipédia UTF8 page ici.

+----------------+----------+----------+----------+----------+
| Unicode        | Byte 1   | Byte 2   | Byte 3   | Byte 4   |
+----------------+----------+----------+----------+----------+
| U+0000-007F    | 0xxxxxxx |          |          |          |
| U+0080-07FF    | 110yyyxx | 10xxxxxx |          |          |
| U+0800-FFFF    | 1110yyyy | 10yyyyxx | 10xxxxxx |          |
| U+10000-10FFFF | 11110zzz | 10zzyyyy | 10yyyyxx | 10xxxxxx |
+----------------+----------+----------+----------+----------+

Les caractères Unicode dans le tableau ci-dessus sont construits à partir des bits:

000z-zzzz yyyy-yyyy xxxx-xxxx

où la z et y bits sont supposé être égal à zéro où ils ne sont pas donnés. Certains octets sont considérées comme illégales comme un octet de départ, car ils sont soit:

• inutile: 2-séquence d'octets en commençant par 0xc0 ou 0xc1 donne en fait un point de code, moins de 0x80 qui peut être représenté mieux avec un 1-séquence d'octets.
• utilisé par RFC3629 pour les 4 octets de la séquence ci-dessus U+10FFFF, ou 5 octet 6 octet séquences. Ce sont les octets 0xf5 par 0xfd.
• juste utilisé: octets 0xfe et 0xff.

En outre, à la suite d'octets dans un multi-séquence d'octets qui ne commencent pas par des bits "10" sont illégales.

Considérez, par exemple, la séquence [0xf4,0x8a,0xaf,0x8d]. C'est un 4-séquence d'octets que le premier octet tombe entre 0xf0 et 0xf7.

    0xf4     0x8a     0xaf     0x8d
= 11110100 10001010 10101111 10001101
       zzz   zzyyyy   yyyyxx   xxxxxx

= 1 0000 1010 1011 1100 1101
  z zzzz yyyy yyyy xxxx xxxx

= U+10ABCD

Pour votre requête spécifique avec le premier octet 0xe6 (longueur = 3), la séquence d'octets est:

    0xe6     0xbe     0xb3
= 11100110 10111110 10110011
      yyyy   yyyyxx   xxxxxx

= 01101111 10110011
  yyyyyyyy xxxxxxxx

= U+6FB3

Si vous le cherchez dans le code ici, vous verrez que c'est celui que vous aviez dans votre question: 澳.

De montrer comment le décodage fonctionne, je suis retourné à mes archives pour retrouver mon UTF8 code de traitement. J'ai eu à se transformer un peu pour en faire un programme complet et le codage a été supprimé (car la question était vraiment sur le décodage), donc j'espère que je n'ai pas introduit des erreurs de la couper et coller:

#include <stdio.h>
#include <string.h>

#define UTF8ERR_TOOSHORT -1
#define UTF8ERR_BADSTART -2
#define UTF8ERR_BADSUBSQ -3
typedef unsigned char uchar;

static int getUtf8 (uchar *pBytes, int *pLen) {
    if (*pLen < 1) return UTF8ERR_TOOSHORT;

    /* 1-byte sequence */
    if (pBytes[0] <= 0x7f) {
        *pLen = 1;
        return pBytes[0];
    }

    /* Subsequent byte marker */
    if (pBytes[0] <= 0xbf) return UTF8ERR_BADSTART;

    /* 2-byte sequence */
    if ((pBytes[0] == 0xc0) || (pBytes[0] == 0xc1)) return UTF8ERR_BADSTART;
    if (pBytes[0] <= 0xdf) {
        if (*pLen < 2) return UTF8ERR_TOOSHORT;
        if ((pBytes[1] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        *pLen = 2;
        return ((int)(pBytes[0] & 0x1f) << 6)
            | (pBytes[1] & 0x3f);
    }

    /* 3-byte sequence */
    if (pBytes[0] <= 0xef) {
        if (*pLen < 3) return UTF8ERR_TOOSHORT;
        if ((pBytes[1] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        if ((pBytes[2] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        *pLen = 3;
        return ((int)(pBytes[0] & 0x0f) << 12)
            | ((int)(pBytes[1] & 0x3f) << 6)
            | (pBytes[2] & 0x3f);
    }

    /* 4-byte sequence */
    if (pBytes[0] <= 0xf4) {
        if (*pLen < 4) return UTF8ERR_TOOSHORT;
        if ((pBytes[1] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        if ((pBytes[2] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        if ((pBytes[3] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        *pLen = 4;
        return ((int)(pBytes[0] & 0x0f) << 18)
            | ((int)(pBytes[1] & 0x3f) << 12)
            | ((int)(pBytes[2] & 0x3f) << 6)
            | (pBytes[3] & 0x3f);
    }

    return UTF8ERR_BADSTART;
}

static uchar htoc (char *h) {
    uchar u = 0;
    while (*h != '
#include <stdio.h>
#include <string.h>
#define UTF8ERR_TOOSHORT -1
#define UTF8ERR_BADSTART -2
#define UTF8ERR_BADSUBSQ -3
typedef unsigned char uchar;
static int getUtf8 (uchar *pBytes, int *pLen) {
if (*pLen < 1) return UTF8ERR_TOOSHORT;
/* 1-byte sequence */
if (pBytes[0] <= 0x7f) {
*pLen = 1;
return pBytes[0];
}
/* Subsequent byte marker */
if (pBytes[0] <= 0xbf) return UTF8ERR_BADSTART;
/* 2-byte sequence */
if ((pBytes[0] == 0xc0) || (pBytes[0] == 0xc1)) return UTF8ERR_BADSTART;
if (pBytes[0] <= 0xdf) {
if (*pLen < 2) return UTF8ERR_TOOSHORT;
if ((pBytes[1] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
*pLen = 2;
return ((int)(pBytes[0] & 0x1f) << 6)
| (pBytes[1] & 0x3f);
}
/* 3-byte sequence */
if (pBytes[0] <= 0xef) {
if (*pLen < 3) return UTF8ERR_TOOSHORT;
if ((pBytes[1] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
if ((pBytes[2] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
*pLen = 3;
return ((int)(pBytes[0] & 0x0f) << 12)
| ((int)(pBytes[1] & 0x3f) << 6)
| (pBytes[2] & 0x3f);
}
/* 4-byte sequence */
if (pBytes[0] <= 0xf4) {
if (*pLen < 4) return UTF8ERR_TOOSHORT;
if ((pBytes[1] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
if ((pBytes[2] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
if ((pBytes[3] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
*pLen = 4;
return ((int)(pBytes[0] & 0x0f) << 18)
| ((int)(pBytes[1] & 0x3f) << 12)
| ((int)(pBytes[2] & 0x3f) << 6)
| (pBytes[3] & 0x3f);
}
return UTF8ERR_BADSTART;
}
static uchar htoc (char *h) {
uchar u = 0;
while (*h != '\0') {
if ((*h >= '0') && (*h <= '9'))
u = ((u & 0x0f) << 4) + *h - '0';
else
if ((*h >= 'a') && (*h <= 'f'))
u = ((u & 0x0f) << 4) + *h + 10 - 'a';
else
return 0;
h++;
}
return u;
}
int main (int argCount, char *argVar[]) {
int i;
uchar utf8[4];
int len = argCount - 1;
if (len != 4) {
printf ("Usage: utf8 <hex1> <hex2> <hex3> <hex4>\n");
return 1;
}
printf ("Input:      (%d) %s %s %s %s\n",
len, argVar[1], argVar[2], argVar[3], argVar[4]);
for (i = 0; i < 4; i++)
utf8[i] = htoc (argVar[i+1]);
printf ("   Becomes: (%d) %02x %02x %02x %02x\n",
len, utf8[0], utf8[1], utf8[2], utf8[3]);
if ((i = getUtf8 (&(utf8[0]), &len)) < 0)
printf ("Error %d\n", i);
else
printf ("   Finally: U+%x, with length of %d\n", i, len);
return 0;
}
') {
        if ((*h >= '0') && (*h <= '9'))
            u = ((u & 0x0f) << 4) + *h - '0';
        else
            if ((*h >= 'a') && (*h <= 'f'))
                u = ((u & 0x0f) << 4) + *h + 10 - 'a';
            else
                return 0;
        h++;
    }
    return u;
}

int main (int argCount, char *argVar[]) {
    int i;
    uchar utf8[4];
    int len = argCount - 1;

    if (len != 4) {
            printf ("Usage: utf8 <hex1> <hex2> <hex3> <hex4>\n");
            return 1;
    }
    printf ("Input:      (%d) %s %s %s %s\n",
        len, argVar[1], argVar[2], argVar[3], argVar[4]);

    for (i = 0; i < 4; i++)
            utf8[i] = htoc (argVar[i+1]);

    printf ("   Becomes: (%d) %02x %02x %02x %02x\n",
        len, utf8[0], utf8[1], utf8[2], utf8[3]);

    if ((i = getUtf8 (&(utf8[0]), &len)) < 0)
        printf ("Error %d\n", i);
    else
        printf ("   Finally: U+%x, with length of %d\n", i, len);

    return 0;
}

Vous pouvez l'exécuter avec votre séquence d'octets (vous aurez besoin de 4 donc l'utilisation de 0 à pavé de sortir) comme suit:

> utf8 f4 8a af 8d
Input:      (4) f4 8a af 8d
   Becomes: (4) f4 8a af 8d
   Finally: U+10abcd, with length of 4

> utf8 e6 be b3 0
Input:      (4) e6 be b3 0
   Becomes: (4) e6 be b3 00
   Finally: U+6fb3, with length of 3

> utf8 41 0 0 0
Input:      (4) 41 0 0 0
   Becomes: (4) 41 00 00 00
   Finally: U+41, with length of 1

> utf8 87 0 0 0
Input:      (4) 87 0 0 0
   Becomes: (4) 87 00 00 00
Error -2

> utf8 f4 8a af ff
Input:      (4) f4 8a af ff
   Becomes: (4) f4 8a af ff
Error -3

> utf8 c4 80 0 0
Input:      (4) c4 80 0 0
   Becomes: (4) c4 80 00 00
   Finally: U+100, with length of 2

Essentiellement, s'il commence par un 0, c'est un 7 bits de code de point. Si elle commence par 10, c'est une continuation d'un multi-octets codepoint. Autrement, le nombre de 1 est vous dire combien d'octets de ce point de code est codé comme.

Le premier octet indique combien d'octets encoder le point de code.

0xxxxxxx 7 bits de point de code codé en 1 octets

110xxxxx 10xxxxxx 10 bits de point de code codé sur 2 octets

110xxxxx 10xxxxxx 10xxxxxx etc.
1110xxxx
11110xxx
etc.

UTF-8 est construit de façon telle qu'il n'y a pas d'ambiguïté possible sur l'endroit où un personnage commence et combien d'octets il a.

C'est vraiment simple.

• Un octet dans la gamme 0x80 à 0xBF est jamais le premier octet d'un caractère.
• Tout autre octet est toujours le premier octet d'un caractère.

UTF-8 a beaucoup de redondance.

Si vous voulez savoir combien d'octets de long d'un personnage, il y a de multiples façons de dire.

• Le premier octet toujours vous indique le nombre d'octets de long, le caractère est:
  • Si le premier octet 0x00 à 0x7F, c'est un octet.
  • 0xC2 à 0xDF signifie qu'il est de deux octets.
  • 0xE0 à 0xEF signifie qu'il est trois octets.
  • 0xF0 à 0xF4 signifie qu'il est de quatre octets.
• Ou, vous pouvez simplement compter le nombre d'octets consécutifs dans la gamme 0x80 à 0xBF, parce que ces octets appartiennent tous à la même qualité que la précédente octet.

Quelques octets ne sont jamais utilisées, comme 0xC1 à 0xC2 ou 0xF5 à 0xFF, donc si vous rencontrez ces octets n'importe où, alors vous n'êtes pas à la recherche à l'UTF-8.

L'astuce est dans cette phrase ici:

En UTF-8, chaque point de code de 0 à 127
est stocké dans un octet. Seul le code
points de 128 et ci-dessus sont stockées à l'aide de
2, 3, en fait, jusqu'à 6 octets.

Chaque point de code jusqu'à 127 a le haut ensemble de bits à zéro. Par conséquent, l'éditeur sait que si elle rencontre un octet où le premier bit est à 1, c'est le début d'un de caractères multi-octets.