UTF8 Literale leserlich machen. Welche Unit / Funktion?

[Redeemer]

Zitat:

Zitat von DieDolly (Beitrag 1437338)

irgendwas stimmt mit dieser Zeile nicht

Dein Compiler gibt keine Meldungen aus? Da solltest du vielleicht mal dein Delphi neu installieren.

[DieDolly]

Natürlich macht der das. Es gibt keine überladene Verision von Replace für diesen Aufruf.
Ich glaube das ist ein unlösbares Problem. Dafür gibts einfach zu viele Zeichen.

Ok ich glaube ich kapituliere.
Ich habe denselben String auch in Hex vor mir liegen und da kommt auch nichts richtiges bei raus

Delphi-Quellcode:

function HexToString(S: String): string;
var
 i: Integer;
begin
 Result := '';
 for i := 1 to Length(S) div 2 do
  Result := Result + Char(StrToInt('$' + Copy(S, (i - 1) * 2 + 1, 2)));
end;

// Hex: C480C486

Da sollte rauskommen
ĀĆ

In HexToString werden immer 2 Stellen ausgelesen das weiß ich. Aber woher soll der auch wissen, dass er mal 2 mal 4 auslesen muss und mal auch gar nix, wenn der Buchstabe schon im Klartext vorliegt.

[Schokohase]

Zitat:

Zitat von DieDolly (Beitrag 1437341)

In HexToString werden immer 2 Stellen ausgelesen das weiß ich. Aber woher soll der auch wissen, dass er mal 2 mal 4 auslesen muss und mal auch gar nix, wenn der Buchstabe schon im Klartext vorliegt.

Weil du das Gedöns erst in eine Byte-Folge umwandeln musst. Diese Byte-Folge ist dann UTF-8 kodiert und damit zauberst du aus dieser Byte-Folge auch das gewünschte

Zitat:

ĀĆHallo

[DieDolly]

Wie es aussieht ist das hier kläglich falsch

Delphi-Quellcode:

Bytes := TEncoding.UTF8.GetBytes('C480C486');
 ShowMessage(TEncoding.UTF8.GetString(Bytes));

Das hier gibt mir ÄÄ aus

Delphi-Quellcode:

Bytes := TEncoding.UTF8.GetBytes(HexToString('C480C486'));

[Schokohase]

Delphi-Quellcode:

var
  buffer: TBytes;
  str:string;
begin
  buffer := [$c4,$80,$c4,$86];
  str := TEncoding.UTF8.GetString(Buffer);
end;

[DieDolly]

Aber wie wandle ich

Delphi-Quellcode:

\xc4\x80\xc4\x86

in

Delphi-Quellcode:

 buffer := [$c4,$80,$c4,$86];

um darum gehts ja seit 2 Seiten.
Das ist nur ein Beispielstring. Da könnte alles stehen. Auch Klartext und Mischung aus Klartext und Kodierung.

[Schokohase]

Zitat:

Zitat von DieDolly (Beitrag 1437346)

Aber wie wandle ich

Delphi-Quellcode:

\xc4\x80\xc4\x86

in

Delphi-Quellcode:

 buffer := [$c4,$80,$c4,$86];

um darum gehts ja seit 2 Seiten.
Das ist nur ein Beispielstring. Da könnte alles stehen. Auch Klartext und Mischung aus Klartext und Kodierung.

Nein, aktuell ging es erst einmal darum, dass du verstehst, was du da denn eigentlich vor dir hast - ein UTF8 codiertes Gedöns.

Ich zeige dir jetzt einmal, wie man das bekommt, was du da verarbeiten musst:

Delphi-Quellcode:

function EncodeBytes(const Buffer: TBytes): string;
var
  idx: Integer;
begin
  result := string.Empty;
  for idx := Low(Buffer) to High(Buffer) do
  begin
    if (Buffer[idx] < $20) or (Buffer[idx] > $7F) then
      result := result + string.Format('\x%2.2x', [Buffer[idx]]).ToLowerInvariant()
    else
      result := result + Chr(Buffer[idx]);
  end;
end;

const
  SomeStr = '&#256;&#262;Hallo';

var
  Utf8Buffer: TBytes;
  EncodedBufferStr: string;

begin
  Utf8Buffer := TEncoding.UTF8.GetBytes(SomeStr);
  EncodedBufferStr := EncodeBytes(Utf8Buffer);
  Writeln(EncodedBufferStr); // \xc4\x80\xc4\x86Hallo
  Readln;

end.

Jetzt solltest du auch den Rückweg hinbekommen ...

[DieDolly]

Delphi-Quellcode:

const
  SomeStr2 = '\xc4\x80\xc4\x86Hallo';
begin
 Utf8Buffer := TEncoding.UTF8.GetString(SomeStr2);
 EncodedBufferStr := EncodeBytes(Utf8Buffer);
 showmessage(EncodedBufferStr);

?? Absolut keine Ahnung sorry.

Da braucht man bestimmt eine Dekodierungsfunktion die das alles rückwärts macht aber wie bitte soll man aus \xc4\x80 ein Ā machen? Wenn ich \xc4\x80 in Bytes umwandle habe ich mehr als 1 Zeichen in dem Array. Insgesamt in dem Fall 8 lang ist das Array. Ich kann ja nicht einfach blind 8 Stellen auslesen. Da könnte auch \16 für ein Leerzeichen stehen wo ich weniger auslesen müsste.

Das ging wohl in die Hose. Ehrlich gesagt verstehe ich nicht einmal was ich da mache.
Ich dachte ich entferne alle \x-Vorkommen und jeweils die nächsten 2 Zeichen danach schreibe ich in ein TBytes-Array.

Delphi-Quellcode:

function DecodeBytes(const Buffer: TBytes): string;
var
 idx: Integer;
 skip: Integer;
 counter: Integer;
begin
 skip := 0;
 counter := 0;
 for idx := Low(Buffer) to High(Buffer) do
  begin
   if skip = 2 then
    begin
     Result[counter] := Chr(Buffer[idx]) + Chr(Buffer[idx + 1]);
     Inc(counter);
    end;

   if Chr(Buffer[idx]) + Chr(Buffer[idx + 1]) = '\x' then
    begin
     skip := 2;
    end
   else
    begin
     skip := 0;
     Result[counter] := Chr(Buffer[idx]);
     Inc(counter);
    end;
  end;
end;

Das deprimiert mich gerade so sehr, dass ich Delphi und auch sonst alles mit Programmierung am liebsten nie wieder anfassen möchte.

[Schokohase]

Zitat:

Zitat von DieDolly (Beitrag 1437351)

aber wie bitte soll man aus \xc4\x80 ein Ā machen?

Das kann ich dir auch nicht sagen. Das wäre mir auch viel zu kompliziert.

Ich ziehe ja auch nicht das Hemd und die Hose gleichzeitig an, denn sonst falle ich auf die Fre**e.

Aber der umgekehrte Weg den ich dir gezeigt habe macht das ja auch nicht alles auf einen Schlag.

Da wird ein String in eine Byte-Folge umgewandelt.
Diese Byte-Folge wird nun in einen String kodiert und dort befinden sich nur noch 7-Bit ASCII Zeichen (bzw. solche die man mit 7-Bit ASCII darstellen könnte).

Also suchen wir nach einem Weg, um aus diesem wieder ein Byte-Folge zu machen (und nicht sofort den gesuchten String!).

Dazu könnten wir dieses TRegEx nehmen

Delphi-Quellcode:

type
  TRegDecoder = class
  private const
    pattern = '\\x((\d|[a-f]*){2})';
    function unescape(const match: TMatch): string;
  public
    function Decode(const str: string): TBytes;
  end;

  { TRegDecoder }

function TRegDecoder.Decode(const str: string): TBytes;
var
  decodedStr: string;
  idx: Integer;
begin
  decodedStr := TRegEx.Replace(str, pattern, unescape);
  SetLength(result, decodedStr.Length);
  for idx := 0 to decodedStr.Length - 1 do
    result[idx] := Ord(decodedStr.Chars[idx]) and $FF;
end;

function TRegDecoder.unescape(const match: TMatch): string;
var
  hexNumber: String;
begin
  hexNumber := '$' + match.Groups[1].Value;
  result := Chr(Byte.Parse(hexNumber));
end;

function DecodeBytes(const str: string): TBytes;
var
  decoder: TRegDecoder;
begin
  decoder := TRegDecoder.Create;
  try
    result := decoder.Decode(str);
  finally
    decoder.Free;
  end;
end;

Dann kommen wir schlussendlich zu

Delphi-Quellcode:

const
  SomeStr = 'ĀĆHallo';

var
  Utf8Buffer, OutBuffer: TBytes;
  EncodedBufferStr: string;
  str: string;

begin
  Utf8Buffer := TEncoding.UTF8.GetBytes(SomeStr);
  EncodedBufferStr := EncodeBytes(Utf8Buffer);
  Writeln(EncodedBufferStr);

  OutBuffer := DecodeBytes(EncodedBufferStr);
  str := TEncoding.UTF8.GetString(OutBuffer);
  // Achtung, kann die Konsole normal nicht korrekt darstellen!
  // Bitte den Wert im Debugger anschauen
  Writeln(str); 

  Readln;

end.

Hinweis

Das ist bestimmt nicht die schnellste Variante, sondern nur eine die funktioniert und die man so mit den bisher gelieferten Informationen hätte lösen können.

[DieDolly]

Bis ich das verstanden habe, vergehen erstmal ein paar Tage. Bestimmt eine Woche.

Seitdem ich das hier das erste mal gesehen habe verzweifle ich schon dran zu verstehen, wie Replace den dritten Parameter akzeptieren kann, der eine Funktion ist die eigentlich einen Parameter benötigt.