Versteht hier jemand Unicode?

[Luckie]

Und genau da hakt es. Bei diesen Zeichen, die nicht im BPM oder wie das heißt drin sind, Außerdem habe ich noch Verständnisprobleme was das BPM ist.

[p80286]

Ich hab mich vor elend langer Zeit mal damit beschäftigt als die Norm noch ganz neu war.
Damals war es vereinfacht so, daß die ersten 8Bit den "Zeichensatz" angeben und die zweiten das eigentliche Zeichen identifizieren.
Das war ungefähr so aufgebaut, daß man als Basis das Standard ASCII hatte, und z.b. für die europ. Sonderzeichen eine eigene Tabelle dazu kam.
Da IBM und M$ es vorzogen die 256 Bytes zu vergewaltigen, hab ich damals die Beschäftigung damit wieder aufgegeben. In der Praxis gab es wohl auch zu viele Ungereimtheiten mit der Umsetzung von z.B. Minus, Gedankenstrich und Bindestrich.

Gruß
K-H

[himitsu]

Jupp, die 16-Bit des UTF-16 wurden in mehrere Bereiche aufgeteilt.

Wobei die Basic Multilingual Plane (also die kodierten Werte von $0000 bis $FFFF) entsprechend aufgeteilt wurden.
Jeder Bereich enthält nur/vorwiegend bestimmte Zeichen (z.B. jeweils einer der vielen Sprachen).

Du kannst dir praktisch diese Grafik als das obere Byte ($xx00) vorstellen, wobei jedes Quadrat ein High-Byte darstellt.
(mehrfarbige Teilkästchen sind nochmals unterteilt)

Wenn man dieses jetzt zeichenweise interpretieren will, dann sind nur die zwei Surrogate-Bereiche wichtig, da davon jeweils ein High-Surrogate und ein Low-Surrogate zusammen ein Zeichen darstellen, welche im Bereich $00010000 bis $0010FFFF darstellen, die ja in die 16 Bit nicht reinpassen würden.
Außerdem wären die privaten Zeichen noch wichtig, also wo der Programmierer quasi selbst festlegen kann, was sie darstellen/enthalten sollen.

Aber wie gesagt, es kommt selten vor, daß diese Zeichen überhaupt mal vorkommen und meißtens ist es nicht schlimm, wenn man dieses Zusammengehören ignoriert und die beiden Surrogates jeweils als ein eigenes UCS2-Zeichen ansieht.



Einzig die Tatsache, daß UTF-32, UTF-16 und UTF-8 zwar alle gültigen Unicodezeichen darstellen können, aber leider intern nicht eine einheitliche Formatierung/Datenstruktur verwenden, finde ich für verwirrend.


UTF-32 ist also über den kompletten bereich direkt adressierbar.
- Datenwert $00000000..$0010FFFF = Zeichenwert
- unpraktisch ist, daß immer 4 Byte pro Zeichen belegt sind und davon auch maximal 0,0259% des gesamten möglichen Wertebereichs genutzt werden (drum nutzt es auch aum einer ... PS: den UCS4String kennt Delphi schon seit vielen Jahren, aber dieser ist leider nicht zuweisungskompatibel zu den anderen Strings )

UTF-16 ist großteils auch direkt adressierbar und der Rest ist in den Surrogates kodiert
- Datenwert $0000..$FFFF = Zeichenwert $0000..$FFFF
- die Surrogates = Zeichenwert $000010000..$0010FFFF

UTF-8 ist auch bekannt
- Datenwert $00..$7F = Zeichenwert $00..$7F
- Datenwerte $80..FF °1 = $000000080..$0010FFFF
°1 Bitweise auf ausreichend viele Bytes verteilt

[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.

[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;

[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

[Assarbad]

Zitat von himitsu:

UTF-32 ist also über den kompletten bereich direkt adressierbar.
- Datenwert $00000000..$0010FFFF = Zeichenwert
- unpraktisch ist, daß immer 4 Byte pro Zeichen belegt sind und davon auch maximal 0,0259% des gesamten möglichen Wertebereichs genutzt werden (drum nutzt es auch aum einer ... PS: den UCS4String kennt Delphi schon seit vielen Jahren, aber dieser ist leider nicht zuweisungskompatibel zu den anderen Strings )

Dein Browser kann kein Javascript?

Der ECMAScript-Standard auf dem Javascript aufbaut benutzt meines Wissens nach intern UTF-32.

Zitat von himitsu:

UTF-8 ist auch bekannt
- Datenwert $00..$7F = Zeichenwert $00..$7F
- Datenwerte $80..FF °1 = $000000080..$0010FFFF
°1 Bitweise auf ausreichend viele Bytes verteilt

Die einfachste Kodierung überhaupt, da auf die Reihenfolge der Bytes nicht geachtet werden muß. Das macht man sich vielleicht sonst nicht so klar, aber das ist ein riesiger Vorteil.