UTF-8 Decodierung
|
Algorithmus zur Decodierung UTF8 → Unicode
(ohne Gewähr):
Nur Zeichen 0..247 ( #00..F7 )
sind zulässig, Zeichen 248..255 ( #F8..FF )
sind illegal.
①
Zeichen 0..127
(→ ASCII-Bereich,
#00..7F) werden ohne Umwandlung direkt verwendet.
②
Zeichen 128..191 (#80..BF) sind Folge-Bytes.
Sie dürfen nur nach einem der nachfolgend aufgezählten
Start-Bytes auftreten.
③
Zeichen 192..223 (#C0..DF) bezeichnen
den Beginn einer 2-Byte-Folge. Das folgende Byte muss ein Folgebyte
(s.o.) sein.
④
Zeichen 224..239 (#E0..EF) bezeichnen
den Beginn einer 3-Byte-Folge. Die beiden folgenden Bytes müssen
Folgebytes (s.o.) sein.
Auch das ↑ BOM
( EF BB BF ) enthält daher legale Zeichen.
⑤
Zeichen 240..247 (#F0..F7) bezeichnen
den Beginn einer 4-Byte-Folge. Die 3 folgenden Bytes müssen
Folgebytes (s.o.) sein.
|
⑥
Decodierung einer 2-Byte-Folge:
Isoliere aus dem Startbyte die niedrigsten 5 Bit und verschiebe sie um 6 Bit nach links.
Isoliere aus dem Folgebyte die niedrigsten 6 Bit.
ODER-verknüpfe die 2 Bytes zum Ergebnis.
⑦
Decodierung einer 3-Byte-Folge:
Isoliere aus dem Startbyte die niedrigsten 4 Bit und verschiebe sie um 12 Bit nach links.
Isoliere aus dem 1. Folgebyte die niedrigsten 6 Bit und verschiebe sie um 6 Bit nach links.
Isoliere aus dem 2. Folgebyte die nierdigsten 6 Bit.
ODER-verknüpfe die 3 Bytes zum Ergebnis.
|
Zur Codierung werden Funktionen bzw. Operatoren auf
→ Bit-Ebene benötigt.
Falls eine Programmiersprache diese nicht bietet, dann kann man diese Funktionen
durch Arithmetik ersetzen:
•
Die Isolierung von Bits erfolgt durch die "bitwise AND"-Funktion.
Sie wird durch die
→ Modulo-Funktion ersetzt.
•
Die Links-Verschiebung (left-shift) wird durch Multiplikation mit einem
Vielfachen von 2 ersetzt.
•
An Stelle der ODER-Verknüpfung (bitwise OR) wird die Addition verwendet.
|
Unicode-Zeichen ohne Äquivalent:
●
Ideal zur Unicode-Ausgabe geeignet ist u.a.
→ XML
bzw. → HTML,
weil man damit jedes Unicode-Zeichen weltweit eindeutig
codieren und (z.B. auf Webseiten) darstellen kann.
●
Bei anderen Zeichencodes mit kleinerem Umfang (z.B.
→ ISO-8859-1)
treten nicht übersetzbare Zeichen auf, z.B. 'slawische' Zeichen
wie Čœřŝž
Derartige Zeichen werden manchmal durch andere Zeichen 'angenähert',
z.B. Cörsz das erfordert jedoch aufwändige
Programme und trifft dennoch daneben.
Im Zweifel werden sie am besten mit dem Zeichen ? decodiert.
|
Das
→ Javascript-Beispiel (vereinfacht, ohne Gewähr) wird für die
Live-Decodierung von UTF-8 auf dieser Webseite verwendet. Das Beispiel lässt sich
leicht auf andere gängige Programmiersprachen übertragen.
function utf8_to_string(utf) {
var str="";
var o1=o2=o3=i=0;
while(i<utf.length) {
o1=utf.charCodeAt(i);
// direkt codiert (1-Byte)
if (o1<128) {
str+=String.fromCharCode(o1);
}
// Fehler
else if(o1<192) {str+="?";}
// 2-Byte UTF-8: U+0080..U+07FF
else if(o1<224) {
o2=utf.charCodeAt(i+1);
str+=String.fromCharCode(((o1&31)<<6) | (o2&63));
i++;
}
// 3-Byte UTF-8: U+0800..U+FFFF
else if (o1<240) {
o2=utf.charCodeAt(i+1);
o3=utf.charCodeAt(i+2);
str+=String.fromCharCode(((o1&15)<<12) | ((o2&63)<<6) |
(o3&63));
i+=2;
}
// Fehler
else {str+="?";}
i++;
}
return str;
}
|
Das
→ PHP-Beispiel (vereinfacht) kann man z.B. zum Transfer von Text aus
einer UTF-codierten Datenbank auf eine Webseite verwenden. Die in PHP
fehlenden Bit-Level Funktionen werden ersetzt.
Verschiedene PHP-Module bieten Funktionen ähnlicher Funktionalität,
die jedoch bei Tests nicht immer wunschgemäß funktioniert haben.
Dieses Beispiel erzeugt aus allen UTF-8 Zeichen sauberen HTML-Code (ohne Gewähr):
function utf8_to_html($s) {
$h="";
$i=0;
while($i<strlen($s)) {
$c1=substr($s,$i,1);
$o1=ord($c1);
// direkt codiert (1-Byte)
if($o1<32) {
if($o1==9) {$h.=' ';}
elseif($o1==10) {$h.="<br />\n";}
}
elseif($o1<128) {
}
// Fehler
elseif($o1<192) {$h.="?";}
// 2-Byte UTF-8: U+0080..U+07FF
elseif($o1<224) {
$o2=ord(substr($s,$i+1,1));
$uc=($o1-192)*64 + $o2-128;
$h.="&#$uc;";
$i++;
}
// 3-Byte UTF-8: U+0800..U+FFFF
elseif($o1<240) {
$o2=ord(substr($s,$i+1,1));
$o3=ord(substr($s,$i+2,1));
$uc=($o1-224)*4096 + ($o2-128)*64 + $o3-128;
$h.="&#$uc;";
$i+=2;
}
// Fehler
else {$h.="?";}
$i++;
}
return $h;
}
Beispiele:
►
Das 1-Byte-Zeichen U+3C wird z.B.
in <
codiert, das ergibt auf einer Webseite die korrekte Anzeige des
Zeichens <
Andernfalls würde dieses Zeichen als HTML-'Programm' aufgefasst
und einen Fehler verursachen.
►
Der 2-Byte UTF-8 Code #C384 bezeichnet das
Zeichen Ä und wird
in Ä codiert. Das ergibt auf jeder Webseite
die gleiche korrekte Anzeige des Zeichens Ä
♦ Details zur
HTML-Codierung von Zeichen.
|
Das Beispiel für die
→ Programmiersprache C/C++ arbeitet etwas abweichend von den
übrigen Beispielen, weil Strings in C/C++ anders verwendet werden:
•
Demo-Programm main()
Eine UTF-8 Text-Datei utf_test.txt wird
geöffnet und wie üblich zeilenweise gelesen. Das Programm muss
seine Funktion danach richten, was mit dem decodierten Text geschehen soll.
In diesem Beispiel wird der Text zu einer ganzen Zahl
(Unicode) decodiert,
anschließend als
→
XML-Entity codiert und ausgegeben.
•
(Nur) In der 1. Zeile wird mit Funktion check_bom()
geprüft, ob ein BOM eingetragen ist, und dieses allenfalls entfernt.
•
Danach wird der UTF-8 Text jeder Zeile in der
String-Variablen str gelesen und an
Funktion utf8_decode() übergeben.
Das Ergebnis (Anzahl der Ergebnis-Zeichen) wird nach der Zeilen-Nummer
ausgegeben.
•
Anschließend wird der decodierte
→
XML- bzw.
→ HTML-konforme Text ausgegeben.
►
Funktion check_bom() erhält den Text
einer Zeile als String-Pointer.
•
Sie gibt eine ganze Zahl [0,1] zurück,
je nachdem, ob das BOM gefunden wurde oder nicht.
•
Ein vorhandenes BOM wird aus dem String entfernt, damit dieser weiter
decodiert werden kann.
►
Funktion utf8_decode() decodiert einen UTF-8
codierten String, der als Pointer übergeben wird. Das decodoerte
Ergebnis wird als XML-konformer Text in den gleichen String eingetragen,
eine ganze Zahl mit der Länge des Ergebnis-Strings in Byte wird
zurückgegeben.
•
Der erhaltene String s wird in den lokalen
String-Buffer t kopiert und dort aufgearbeitet.
•
Die Ergebnis-Bytes werden schrittweise in den
String s eingetragen, der neu aufgebaut und
zuletzt mit einem 0-Byte abgeschlossen wird.
•
Der Algorithmus zur UTF-8 Decodierung folgt den übrigen
Beispielen dieser Seite.
Je nach Bedarf werden 1..3 Bytes an die
Variablen ic0, ic1, ic2 übergeben.
•
Einzelne ASCII-Bytes werden direkt ausgegeben.
•
2 oder 3 UTF8-Bytes werden in der Variablen iuc
decodiert.
■
An dieser Stelle kann man die Funktion ändern, um den
fertig decodierten Unicode iuc
(rot hervorgehoben) beliebig zu verwenden.
Im Beispiel wird der Unicode mit der
→ Standard-Funktion sprintf() in einen
→ XML-Entity String umgewandelt, an den lokalen
String-Buffer h übergeben und mit
Standard-Funktion strcat() an den
Ergebnis-String s angehängt.
Dabei wird auch das abschließende 0-Byte eingetragen.
•
Die while-Schleife wird abgebrochen, wenn
im Eingangs-String ein 0-Byte gefunden wird
(ic0==0).
Zur Sicherheit wird die Schleife spätestens nach 100 Bytes abgebrochen.
Setzen sie diese Grenze und die Größe des Buffer-Strings zur
praktischen Anwendung hinauf.
•
Nach erfolgter Decodierung wird die aktuelle Länge des
Ergebnis-Strings s an die
Variable j zugewiesen. Ihr Wert-1 wird zuletzt
als Gesamt-Länge des Ergebnis-Strings an das aufrufende Programm
zurückgegeben.
|
C/C++ Programm-Beispiel zum Lesen einer UTF-8 Text-Datei:
#include <stdio.h>
#include <string.h>
int check_bom(char*);
int utf8_decode(char*);
int main() {
int ilen,iline;
char path[80],str[80];
FILE *fhr;
strcpy(path,"/home/ich/utf_test.txt");
// strcpy(path,"C:\\Daten\\utf_test.txt");
fhr=fopen(path,"r");
iline=0;
while (!feof(fhr)) {
str[0]=0;
fgets(str,sizeof(str),fhr);
if(!iline) {
if(check_bom(str)) {printf("# BOM #\n");}
}
ilen=utf8_decode(str);
printf("[line %d]: str[len=%d] = %s",iline++,ilen,str);
}
fclose(fhr);
return 0;
}
int check_bom(char *t) {
int i;
unsigned int ic;
i=0;
if((t[0]&0xFF)==0xEF &&
(t[1]&0xFF)==0xBB && (t[2]&0xFF)==0xBF) {
while(i<1000) {
ic=t[i+3]&0xFF;
t[i]=ic;
if(!ic) {i=9999;}
i++;
}
i=1;
}
return i;
}
int utf8_decode(char *s) {
unsigned int i,ic0,ic1,ic2,j,iuc;
char t[100],h[10];
strcpy(t,s);
i=j=0;
s[0]=0;
while(i<100) {
ic0=t[i++]&0xFF;
if(ic0<128) {
// iuc=ic0;
s[j++]=ic0; // 1-Byte ASCII
s[j]=0;
}
else{
if(ic0<192) { // Fehler
s[j++]=(int)"?";
s[j]=0;
}
else{
ic1=t[i++] & 0xFF;
if(ic0<224) { // 2 Byte
iuc=((ic0&31)<<6) | (ic1&63);
sprintf(h,"&#x%X;",iuc);
strcat(s,h);
j=strlen(s);
}
else if(ic0<240) { // 3 Byte
ic2=t[i++] & 0xFF;
iuc=((ic0&15)<<12) | ((ic1&63)<<6) | (ic2&63);
sprintf(h,"&#x%X;",iuc);
strcat(s,h);
j=strlen(s);
}
else{ // Fehler
s[j++]=(int)"?";
s[j]=0;
}
}
}
if(!ic0) {i=9999;}
}
return j-1;
}
|
|
Wenn man mit diesem C-Programm die vom oben (Codierung)
gezeigten C-Programm hergestellte UTF-8 Text-Datei analysiert, dann
erhält man diese Ausgabe:
# BOM #
[line 0]: str[len=3] = AZ
[line 1]: str[len=13] = ÄÜ
[line 2]: str[len=23] = α€ω
Sie sind eingeladen, mit den Beispielen zu experimentieren und damit
Texte mit beliebigen
→ Unicode-Zeichen zu codieren und zu decodieren.
|
Wenn man die decodierten und als XML-Strings neuerlich codierten
Strings in ein XML-Dokument oder in eine HTMl-Webseite einsetzt, dann
erhält man das korrekte Ergebnis
# BOM #
[line 0]: str[len=3] = AZ
[line 1]: str[len=13] = ÄÜ
[line 2]: str[len=23] = α€ω
Die als Zwischen-Produkt erzeugte Text-Datei wird mit allen gängigen
Text-Editor-Programmen korrekt angezeigt, z.B. (auf Windows) mit
Notepad++.
|
Zeichencodes
Live-Test
Ein besonderer Vorteil ist die variable Anzahl von Bytes pro Zeichen:
Häufig verwendete Zeichen (ASCII-Bereich) benötigen nur 1 Byte,
seltener verwendete 2...6 Bytes.
MS-Programme neigen dazu, Texte ungefragt im firmen-eigenen
Wenn andere Büro-Programme keine Option zum Export von Text
im UTF-8 Format anbieten, dann kann man mit Basic (VBA) eine Ersatz-Funktion programmieren n
(
