Opération

Reprenons notre exemple %E2%80%99.

Commençons par enlever les % qui servent de séparateurs. La première partie est codée sur E2. En nous référant à la table, nous voyons que :

• E2 est compris entre E0 et EF. Il s'agit donc du premier byte sur une séquence de 3 bytes.

• 80 est compris entre 80 et BF. Il s'agit d'un byte suivant dans une séquence multi-bytes.

• 99 est compris entre 80 et BF. Il s'agit d'un byte suivant dans une séquence multi-bytes.

Nous savons donc déjà que nous n'utiliserons que 3 caratères : E2, 80, 99 encodés en hexadécimal. S'il y en a plus, ils feront partie d'une ou plusieurs autres séquences (et il faudra donc recommencer l'opération).

Ensuite, enlevons les informations ajoutées. Pour cela, convertissons le caractère en binaire :

• E2 --> 11100010

• 80 --> 00000000

• 99 --> 10011001

soit au total, pour 3 bytes : 111000100000000010011001

Soustrayons ensuite le masque d'encodage à ce résultat :

Le masque d'encodage est 1110xxxx 10xxxxxx 10xxxxxx, soit pour notre opération 11100000 10000000 10000000.

L'opération binaire simple donne :

• E2 --> 11100010 - 11100000 = 00000010

• 80 --> 00000000 - 10000000 = 00000000

• 99 --> 10011001 - 10000000 = 00011001

Soit, au total : 00000010 00000000 00011001 --> 000000100000000000011001

Mais l'opération n'est pas finie car l'encodage nécessite d'ajouter 4 bits sur le premier octet et 2 bits sur les autres. Il faut donc les enlever :

• 00000010 --> 10

• 00000000 --> 000000

• 00011001 --> 011001

Et de reconcaténer le tout :

10000000011001, ce qui, en hexadécimal, donne : 2019. ou en décimal : 8217

Le compte est bon !

Remarques

Ce format d'encodage possède de nombreux avantages. Il permet notamment d'obtenir des motifs uniques. En effet, l'on pourait se poser la question de savoir si E2, 80 ou 99 ne pourraient pas apparaître dans d'autres motifs que ceux de longueur 3 bytes. Et bien non ! Le simple fait d'ajouter des bits au début de chaque chaîne et que cette séquence soit séparée du reste pas un 0 rend automatiquement chaque groupe du motif unique dans son ensemble. E0 ne pourra pas être retrouvé dans un groupement de 1 ou 2 bytes. Tout comme 80 ou 99, etc.

Cela permet donc d'utiliser sed pour notre conversion. Car chaque élément étant unique dans son groupe, nous sommes certains de ne pas avoir plusieurs possibilités de décodage.

Amélioration

Nous pouvons à ce stade faire des remarques et, à partir de celles-ci, faire quelques améliorations, ou plutôt quelques raccourcis pour l'algorithme de décodage.

Le debut de l'octet encodé comprend obligatoirement un morceau de paramétrage de l'encodage et une partie codant la valeur. La permière partie est une partie fixe. Les deux parties sont obligatoirement séparées par un 0. Ce qui fait que, au lieu d'effectuer une soustraction binaire plus un troncage de la partie inutile, il suffit juste d'ôter la première partie (y compris avec le 0 intermédiaire) et nous obtenons directement le résultat. La seule différence est que nous avons considéré d'un seul coup la chaîne non pas comme une valeur binaire, mais comme une valeur chaîne. Ainsi, il n'y a qu'une seule opération à effectuer : le troncage de la partie de paramétrage.

Automatisation

Maintenant que nous avons compris la méthode, automatisons la avec, par exemple, un shell UNIX.

Nous pouvons faire quelques observations. Il faudra passer d'une partie encodée en hexadécimal en binaire, plus l'opération inverse. Ce qui fait que l'opérateur bc s'impose naturellement.

La procédure à suivre pour convertir un texte encodé est la suivante :

1. Convertir de tous les éléments déjà référencés :

QUERY_STRING=${1}
file0=$(echo ${QUERY_STRING} | sed -f html2utf8.sed)

Cela a pour effet d'éliminer une partie du décodage. Si le fichier html2utf8.sed n'existe pas, il faut le créer.

2. Isoler tous les éléments de la forme %xx :

echo ${file0} | sed 's/\%\([0-9A-F][0-9A-F]\)/\$\%\1\$/g' | tr '$' '\n' | grep "^%" | sed 's/^\%//g' | awk '{print NR ";" $0}' > ${file1}

On découpe ici le texte en entrée en isolant chaque %xx sur une ligne, puis on ne récupère que cette ligne par un grep "^%". Les sauts de lignes sont forcés avec le $ introduit par sed 's/\%\([0-9A-F][0-9A-F]\)/\$\%\1\$/g' puis appliqués par tr '$' '\n'.

awk '{print NR ";" $0}' permet de numéroter les lignes, cela sera important pour la suite, car il faudra conserver le lien entre la valeur d'origine et la valeur finale.

3. Convertir ces lignes en binaire :

cat ${file1} | awk -F";" 'BEGIN { print "ibase=16;obase=2"} {print $2}'| bc | awk '{print "00000000" $1}' | awk '{print NR ";" substr($1,length($1)-7,8)}' > ${file2}

La partie

awk '{print "00000000" $1}' | awk '{print NR ";" substr($1,length($1)-7,8)}'

permet de rajouter les 0 manquants à une valeur binaire commençant par une valeur non significative. On ajoute à gauche 8 zéro, puis on ne récupère que les 8 derniers binaires pour reformer un octet valide et complet.

De la même façon, on numérote les lignes. Ainsi la ligne binaire n correspond à a ligne n de départ.

4. Décoder le format :

join -t";" -o 1.2,2.2 -j 1 ${file1} ${file2} | awk -F";" -f html2utf8.awk | awk '{print NR ";" $0}' > ${file3}

join -t";" -o 1.2,2.2 -j 1 ${file1} ${file2} permet de récupérer le lien source-->binaire.

La conversion se fait par application de l'algorithme de décodage, grâce au processeur awk :

BEGIN {}

(substr($2,1,4)==1110) {
# cas où le caractère est codé sur 3
n=3
m=substr($2,5,4) 
p="\\%" $1 }

(substr($2,1,3)==110) { 
# cas où le caractère est codé sur 2
n=2
m=m substr($2,4,5)
p=p "\\%" $1}

(substr($2,1,2)==10) { 
# cas d'une suite 
n=n-1
m=m substr($2,3,6)
p=p "\\%" $1
if (n==1) {
n=0
print p ";" m
p=""
m=""
}}

(substr($2,1,1)==0) { 
# cas où le caractère est codé sur 1 
print "\\%" $1 ";" $2
}

END {}

Le retour commence à la fois à former le motif d'entrée de sed et de recomposer (décoder) le motif de sortie, ici sous forme binaire.

5. Encoder le motif binaire en décimal :

cat ${file3} | awk -F";" 'BEGIN { print "ibase=2"} {print $3}'| bc | awk '{print NR ";" $0}' > ${file4}

De la même façon, on conserve la numérotation des lignes pour conserver le lien avec le motif d'origine.

6. Formation de la commande sed :

join -t";" -o 1.2,2.2 -j 1 ${file3} ${file4} | sort | uniq | awk -F";" '{print "s/" $1 "/\\&#" $2 "\\;/g"}' > ${file5}

sort | uniq permet d'éliminer les doublons.

La jointure permet de rassembler le motif de départ avec le motif d'arrivée sans perdre le lien.

7. Recontruire le fichier final en ajoutant les nouveautés, le fichier s'enrichit donc automatiquement au fur et à mesure :

cat html2utf8.sed > html2utf8.temp
cat ${file5} >> html2utf8.temp
cat html2utf8.temp | sort | uniq > html2utf8.sed

8. Repasser le texte de départ dans le filtre afin de remplacer ce qui manquait :

echo ${file0} | sed -f html2utf8.sed

Ou bien, pour un traitement plus rapide, uniquement sur la partie nouvelle :

echo ${file0} | sed -f ${file5}