Versteht hier jemand Unicode?

[Luckie]

Also im BMP Bereich sind alle zeichen kodiert, die am gebräuchlichsten sind. Dieser Bereich liegt in den 16 Bit. Dann gibt es noch den zweiten Bereich der mit zwei mal 16-Bit kodiert ist. Ist das soweit richtig? OK, nehmen wir mal an, ich hätte es richtig verstanden. Womit ich jetzt Probleme habe ist der Absatz, wo das mit den zwei mal 16-Bit erklärt wird:

Zitat:

Unicode-Zeichen außerhalb der BMP (d. h. U+10000 bis U+10FFFF) werden durch zwei 16-Bit-Wörter (engl. code units) dargestellt, die wie folgt gebildet werden:

Von der Nummer des Zeichens wird zunächst die Zahl 65536 (10000hex) abgezogen, wodurch eine 20-Bit-Zahl im Bereich von 00000hex bis FFFFFhex entsteht, die anschließend in zwei Blöcke zu je 10 Bit aufgeteilt und dem ersten Block die Bitfolge 110110, dem zweiten Block dagegen die Bitfolge 110111 vorangestellt wird. Das erste der beiden so entstandenen 16-Bit-Wörter bezeichnet man als High-Surrogate, das zweite als Low-Surrogate, und ihren Namen entsprechend enthält das High-Surrogate die 10 höherwertigen, das Low-Surrogate die 10 niederwertigen Bits des um 65536 verringerten ursprünglichen Zeichencodes. Der Codebereich von U+D800 bis U+DBFF (High-Surrogates) und der Bereich von U+DC00 bis U+DFFF (Low-Surrogates) ist speziell für solche UTF-16-Ersatzzeichen reserviert und enthält daher keine eigenständigen Zeichen.

Kann mir das noch mal jemand bitte erklären? Ich verstehe da nur Bahnhof.

[BUG]

Also das Ganze funktioniert wie Escapen in Strings:

Ein UFT-16 Zeichen ist 16 Bit lang.
Also können darin nur die Zeichen von $0 bis $FFFF darin kodiert werden.

Da es aber viel mehr Unicodezeichen (also zusätzlich $10000 bis $10FFFF) gibt, müssen diese irgendwie codiert werden.
Wenn ein solches Zeichen codieren willst, ziehst du erstmal $10000 davon ab. Nun hast du das Zeichen in den Bereich $0 bis $FFFF codiert, also 20 Bit. (1)

Nun reserviert man sich innerhalb der 2^16 Zeichen einige, die man per Definition nicht als einzelne Zeichen betrachtet, sondern als "Surrogate"
Hier sind es alle, die (links mit Nullen aufgefüllt) binär codiert mit 110110 oder 110111 beginnen.

110110 und 110111 sind jeweils 6 Bit lang, du hast bei den Surrogates also jeweils 10 Bit "Nutzlast".

Dein 20 Bit Zeichen von (1) kannst du in 2 Blöcke je 10 Bit aufteilen.
Vor den ersten Block setzt du die Bitfolge 110110 und erhältst ein High-Surrogate. Vor den zweiten Block die Bitfolge 110111 und erhältst ein Low-Surrogate.

Nun hast du zwei 16-Bit-Folgen, die nach Definition einzeln keine Zeichen sind und zusammen ein Zeichen im Bereich $10000 bis $10FFFF codieren.

Damit kannst du nun also gefahrlos Zeichen im genannten Bereich in UTF-16 codieren.

Also aus "abc" mit a, c liegen im Bereich $0..$FFFF ohne die Surrogate Bereiche und b liegt im Bereich $100000..$10FFFF wird:
"axyc" mit a, c liegen im Bereich $0..$FFFF ohne die Surrogate Bereiche sowie x ist ein High-Surrogate und y ist ein Low-Surrogate.

[Luckie]

Puh, ist das kompliziert. ich werde es mir dann mal zu Gemüt führen.

[BUG]

Zitat von Luckie:

Puh, ist das kompliziert. ich werde es mir dann mal zu Gemüt führen.

Im Ernst: es ist weniger kompliziert als es aussieht.

Im Endeffekt ersetztet du jedes "zu große" Zeichen ($100000..$10FFFF) durch zwei andere, die im normalen Text nicht vorkommen (die Surrogates), also im nicht kodierten Text (UTF-32) als "Nichtzeichen" definiert und damit "verboten" sind.

[himitsu]

Zitat von BUG:

Im Ernst: es ist weniger kompliziert als es aussieht.

...

Ist also fast soein Verfahren, wie das URLEncode auch.
http://php.net/manual/de/function.urlencode.php

[himitsu]

Delphi-Quellcode:

if (TheChar in [$D800..$DBFF{High-Surrogates}, $DC00..$DFFF{Low-Surrogates}]) 
    or (TheChar > $10FFFF) or (weitere) then 
  raise Exception.Create('ungültiges Zeichen')
else if TheChar > $FFFF then begin
  Temp := TheChar - $010000;
  TheWord[0] := (Temp shr 10) or $D800;  // High-Surrogate
  TheWord[1] := (Temp and $03FF) or $DC00;  // Low-Surrogate
end else 
  TheWord[0] := TheChar;