UTF8 Literale leserlich machen. Welche Unit / Funktion?

[DieDolly]

Encoding von Zeichen war noch nie meine Stärke.
Gibt es in delphi eine Unit die aus \xc4\x80 den entsprechenden Buchstaben zaubert?

[Amateurprofi]

Unit System
z.B. so:

Delphi-Quellcode:

var S:String;
begin
   S:=UTF8ToUnicodeString(#$C4#$80);
   ShowMessage(S);
end;

[Der schöne Günther]

Das \x hat nichts mit Encoding zu tun, das sind programmiersprachen-eigene Maskierungen.

Du hast also 2 Bytes und willst das explizit als UTF-8 interpretieren.

Delphi-Quellcode:

TEncoding.UTF8.GetString(..)

Beispiel:

Delphi-Quellcode:

procedure TForm2.FormCreate(Sender: TObject);
const
   input: TBytes = [$c4, $80];
begin
   Caption :=
      TEncoding.UTF8.GetString(input)
      + ' / '
      + TEncoding.Unicode.GetString(input);
end;

[DieDolly]

Zitat:

Das \x hat nichts mit Encoding zu tun, das sind programmiersprachen-eigene Maskierungen.

Zitat:

S:=UTF8ToUnicodeString(#$C4#$80);

Das heißt, dass diese Maskierung in Delphi ein #$ ist?

Wie bekommt man denn einen String den man dann mit StringReplace bearbeitet hat in UTF8ToUnicodeString? Einen string mit ' umschlossen mag er nicht.

[Uwe Raabe]

Zitat:

Zitat von DieDolly (Beitrag 1437324)

Das heißt, dass diese Maskierung in Delphi ein #$ ist?

Im Klartext bedeutet diese Sequenz:

#: Dies ist ein Char, den ich aber mit seiner Ordnungszahl angebe
$: Dies ist eine Zahl in Hexadezimaldarstellung

#13 und #$C sind also identische Chars. Ebenso '0', #48 und #$30.

[DieDolly]

Das macht es noch komplizierter.
Wie bekommt man einen String wie ganz oben denn in TBytes rein oder in einen lesbaren String?
Der Input kann immer wie oben aussehen. Er kann aber auch schon in lesbarer Form vorhanden sein.

Da kann auch reinkommen

Delphi-Quellcode:

\xc4\x80\x16\x16\x16Hallo

Ich dachte an sowas hier aber da passt dieses spezielle A nicht mehr rein

Delphi-Quellcode:

var
 Bytes: TBytes;
begin
 Bytes := [Ord('Ā'), $80, Ord('S')];
 ShowMessage(TEncoding.UTF8.GetString(Bytes));

Aber ich glaube ich habe gerade eh einen Knoten im Kopf.

[Uwe Raabe]

Zitat:

Zitat von DieDolly (Beitrag 1437326)

Da kann auch reinkommen

Delphi-Quellcode:

\xc4\x80\x16\x16\x16Hallo

Ach so, du bekommst dies als String in dein Programm?

[DieDolly]

Ja richig. Das kann ein String sein der Nur aus solchen Literalen besteht, es kann ein Klartext sein oder eine Mischung.
Und ich bin mir nicht sicher, wie ich damit umgehen soll, um aus jeder dieser Varianten den Klartext zu bekommen.

Würde mich über Hilfe freuen.

Sowas hier klappt natürlich auch nicht.

Delphi-Quellcode:

 VonDatei := '\xc4\x80\xc4\x86Hallo';

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

[Der schöne Günther]

Eine dumme Idee: Kommt man mit so etwas in der Richtung weiter?

Delphi-Quellcode:

procedure TTest.p();
const
   input = '\xc4\x80\xc4\x86Hallo';
   pattern = '\\x((\d|[a-f]*){2})';
var
   matchEvaluator: TMatchEvaluator;
begin
   WriteLn( TRegEx.Replace(input, pattern, unescape) );
end;

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

[DieDolly]

ich versuche das gerade zu verstehe und zu kompilieren aber irgendwas stimmt mit dieser Zeile nicht

Delphi-Quellcode:

TRegEx.Replace(input, pattern, unescape)

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

[p80286]

Zitat:

Zitat von DieDolly (Beitrag 1437351)

?? Absolut keine Ahnung sorry.

Kann vorkommen.
zunächst wäre es hilfreich zu wissen aus welcher Quelle der String stammt. Ich vermute: JSON, muß aber nicht sein.
Wenn man die Quelle kennt, weiß man welche Zeichen "escaped" werden müssen, ansonsten mußman halt mit allem Rechnen......

SomeStr2 = '\xc4\x80\xc4\x86Hallo';

In diesem Beispiel wird zunächst einmal ein Byte(C4) definiert, weil die Quelle mit diesem Zeichen nich korrekt umgehen kann. Die nächsten drei Bytes werden ebenfall entsprechend definiert (80,C4,86).

also

mystring:=#$C4+#$80+#$C4+#$86+'Hallo';

Schaust Du in der UTF-Codierung nach, dann entspricht $C480 einem Ä und $C486 einem ´C
es scheint sich also um UTF-8 zu handeln.

Mit der entsprechenden übersetzungsfunktion erhälst du also
'ÄCHallo' (ich bekomme das Acute nich richtig hin:oops:)


Gruß
K-H

[DieDolly]

Zitat:

Kann vorkommen.

Aber nicht so wie bei mir.
Ich habe versucht die Logik einfach irgendwie umzudrehen aber das war wohl der sichere falsche Weg.

[Schokohase]

Zitat:

Zitat von p80286 (Beitrag 1437358)

zunächst wäre es hilfreich zu wissen aus welcher Quelle der String stammt. Ich vermute: JSON, muß aber nicht sein.

Nein, definitiv nicht:

1. Bei JSON ist ein string immer quoted
2. Bei JSON gibt es ein \u???? mit 4 Hex-Ziffern aber eben kein \x?? mit zwei Hex-Ziffern

Nachzulesen unter https://json.org

[Schokohase]

Zitat:

Zitat von DieDolly (Beitrag 1437356)

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.

Das ist ein Delegate bzw. Funktions- oder Methodenzeiger und gehört eigentlich zum Delphi Basiswissen. Wie hast du jemals einen Event zugewiesen, denn da verwendet man nur solche Methodenzeiger mit Parametern?

[DieDolly]

Events habe ich schon dutzende zugewiesen.
Beispielsweise eine Komponente zur Laufzeit erstellen und Events zuweisen die schon im Code liegen.

Aber das da oben sagt mir gar nichts denn der Code-Hint sagt auch nur, dass er einen String als dritten Parameter erwartet.
Verstehe es noch immer nicht und werde das auch nie verstehen. Für mich sieht ein Event anders aus. Kapiere einfach nicht, wo TMatch dann herkommen soll.
Replace() liefert es ja scheinbar nicht, da nur ein String erwartet wird.

Delphi-Quellcode:

class function TRegEx.Replace(const Input, Pattern, Replacement: string): string;

Zum Basiswissen gehört viel. Es gibt schlaue Menschen wie dich die irgendwie alles aufsaugen und es gibt dumme wie mich, die nix kapieren.

[Der schöne Günther]

Was ist deine Delphi-Version? Vielleicht war die Methode in deiner Version noch nicht erfunden 🤷

[Schokohase]

Schlau? Weiß ich nicht ...
Augen offen? Ja auf jeden Fall ...

http://docwiki.embarcadero.com/Libra...TRegEx.Replace

Delphi-Quellcode:

class function Replace(const Input, Pattern, Replacement: string): string; overload; static;
class function Replace(const Input, Pattern: string; Evaluator: TMatchEvaluator): string; overload; static;
class function Replace(const Input, Pattern, Replacement: string; Options: TRegExOptions): string; overload; static;
class function Replace(const Input, Pattern: string; Evaluator: TMatchEvaluator; Options: TRegExOptions): string; overload; static;

Delphi-Quellcode:

type
  TMatchEvaluator = function(const Match: TMatch): string of object;

Eventuell macht das den Unterschied und wirkt auf andere schlau ... obwohl ich einfach nur die Augen offen habe

[Rolf Frei]

mystring := UTF8Decode(#$C4+#$80+#$C4+#$86+'Hallo');

Das ergibt den String "ĀĆHallo"

Das Problem ist nun die "\x.." Zeichen in den entsprechenden 8-bit Zeichen Code umzuwandeln. Habe dazu schnell eine simple Routine geschrieben, die das macht. Diese müsste aber eventuell noch etwas überarbeitet werden, jenach dem was der Quellstring wirklich alles enthalten kann.

Delphi-Quellcode:

function DecodeCStyleString(const AStr: String): String;
var
  HexStr, ResultStr: RawByteString;
  i: Integer;
  IsCharLeadin: Boolean;
begin
  IsCharLeadin := False;
  i := 1;
  while i <= Length(AStr) do
  begin
    IsCharLeadin := AStr[i] = '\';
    if IsCharLeadin then
    begin
      IsCharLeadin := AStr[i+1] = 'x';
      if IsCharLeadin then
      begin
        inc(i, 2);
        HexStr := '$' + AStr[i] + AStr[i+1];
        ResultStr := ResultStr + AnsiChar(StrToInt(HexStr));

        inc(i);
      end
      else
        ResultStr := ResultStr + AnsiChar(AStr[i]);
    end
    else
      ResultStr := ResultStr + AnsiChar(AStr[i]);

    inc(i);
  end;

  Result := UTF8ToString(ResultStr);
end;

...

MyString := DecodeCStyleString('\xc4\x80\xc4\x86Hallo\xc4\x80');
// MyString ist nun "&#256;&#262;Hallo&#256;"

[Incocnito]

Hi Zusammen,

ich würde nicht davon ausgehen, dass eine fremde Datenquelle mir saubere Daten schickt,
also habe ich noch zwei Sachen abgefangen:
1) Wenn nach dem "\x" nicht 2 Hex-Werte kommen, sondern nur einer und der String dann endet.
2) Wenn nach dem "\x" nicht 2 Hex-Werte kommen, sondern andere Zeichen und "StrToInt" schief gehen würde.

Delphi-Quellcode:

function DecodeCStyleString(const AStr: String): String;
var
  HexStr    : RawByteString;
  ResultStr : RawByteString;
  i         : Integer;
  iData     : Integer; // Reicht Word?
begin
  i := Low(AStr);
  while (i <= High(AStr)) do
  begin
    if (AStr[i] = '\') then
    begin
      if ((i+3) < High(AStr)) and (AStr[i+1] = 'x') then
      begin
        Inc(i, 2);
        HexStr := '$' + AStr[i] + AStr[i+1];
        if (TryStrToInt(HexStr, iData)) then
        Begin
          ResultStr := ResultStr + AnsiChar(iData);

          Inc(i);
        end else
        begin
          ResultStr := ResultStr + '\x' + AStr[i];
        end;
      end else
      begin
        ResultStr := ResultStr + AnsiChar(AStr[i]);
      end;
    end else
    begin
      ResultStr := ResultStr + AnsiChar(AStr[i]);
    end;

    Inc(i);
  end;

  Result := UTF8ToString(ResultStr);
end;

Drei Dinge bleiben meiner Meinung nach noch zu klären:
1) Wenn der String mit "\xc" endet, könnte man gaaanz weit ausholen und da "\x0c" von machen,
aber will man das noch "abfangen"? Schließlich könnte man soetwas mitten im Text ja auch nicht erkennen!
2) Der Compiler spuckt noch Warnungen aus über Implizite Typ-Umwandlungen. Und Warnungen sind immer ein Hinweis darauf,
dass man etwas nicht richtig gemacht hat. Jetzt ist jemand gefragt, der sich mit Codepages und Zeichensätzen
auskennt. Man könnt das ganze zwar mit explizitem Typecase umgehen, aber das sagt dem Compiler ja
"ich weiß, was ich tue, mach einfach", aber ich weiß hier gerade nicht was ich tue, also seid ihr gefordert! ;-)
3) Wie im Kommentar schon zu sehen, aber irgendwie auch Teil von Punkt 2 "Reicht evtl. schon ein Word (2 Byte)
für das TryStrToInt?" Außerdem sagte mal jemand, dass "Integer" je nach EXE-Architektur den Standard-Zahltyp darstellt
("EXE-Architektur" ist sicher das falsche Wort, gemeint ist "Bei einem 64-Bit-Programm ist es ein 64-Bit Wert,
bei einem 16-Bit-Programm nur ein 16-Bit Wert"), aber dass kann jetzt auch von einer anderen
Programmiersprache kommen, oder ein totaler Irrläufer sein!

Außerdem gibt es vermutlich noch 1-2 Dinge zu verbessern, ohne gleich mit Pointern das ganze auf's Maximum zu optimieren.

Viel Spaß noch damit.

Liebe Grüße
Incocnito

[Der schöne Günther]

Warum macht ihr so etwas nicht mit regulären Ausdrücken 😐

[Sherlock]

Also bei mir kommt so ein Krempel über SOAP rein. Das wird dann hiermit bereinigt und übersetzt:

Delphi-Quellcode:

uses System.JSON;

var myJSONValue:TJSONValue;


 // 'Gl\xC7\, cknerin' -> 'Glöcknerin'
          temp := StringReplace(temp, '\ ', ' ', []);
          temp := StringReplace(temp, '\n', ' ', []);
          temp := StringReplace(temp, '\, ', '', []);
          myJSONValue := TJSONObject.ParseJSONValue(StringReplace(temp.QuotedString('"'), '\x', '\u00',
            [rfReplaceAll]));
          if Assigned(myJSONValue) then
            temp := myJSONValue.ToString;
          temp := StringReplace(temp, '"', '', [rfReplaceAll]);

Und das wars dann schon. Ein paar sinnvolle trys und Frees bitte ergänzen.

Sherlock

[Uwe Raabe]

So, ich möchte dann bitte auch nochmal (nur so wegen der Vielfalt):

Delphi-Quellcode:

uses
  System.SysUtils,
  System.Classes;

function DecodeCStyleString(const AStr: String): String;
const
  cLeadIn: TBytes = [$5C, $78]; // '\x'
var
  cnt: Integer;
  source: TBytes;
  target: TBytes;
  i: Integer;
begin
  source := TEncoding.UTF8.GetBytes(AStr);
  SetLength(target, Length(source)); // ausreichend Platz schaffen
  cnt := 0;
  i := 0;
  while (i < Length(source)) do
  begin
    if ((i + 3) < Length(source)) and
       CompareMem(@source[I], @cLeadIn[0], 2) and
       (HexToBin(source, I + 2, target, cnt, 1) = 1) then
    begin
      Inc(cnt);
      Inc(i, 4);
      Continue;
    end;
    target[cnt] := source[i];
    inc(cnt);
    Inc(i);
  end;
  Result := TEncoding.UTF8.GetString(target, 0, cnt);
end;

[Schokohase]

@UweRaabe

Ich weiß nicht warum, aber mit dem Code bekomme ich bei Delphi 10.3.2 nur Fehler

Code:

[dcc32 Fehler] Coding.dpr(14): E2029 ')' erwartet, aber ',' gefunden
[dcc32 Fehler] Coding.dpr(28): E2008 Inkompatible Typen
[dcc32 Fehler] Coding.dpr(29): E2015 Operator ist auf diesen Operandentyp nicht anwendbar

Zeile 14 ist die mit der

Delphi-Quellcode:

cLeadIn: TBytes = ($5C, $78); // '\x'

.

[Codehunter]

Also was hier IMHO einer Erleuchtung im Wege steht ist der Mangel an zusätzlichen Informationen. Woher kommt der String, was für ein System, ggf. Quell- und Zielcodepages usw. Ein \xc4 und \x80 sagt ja erstmal nichts weiter aus als den Bytewert 196 und 128. Ohne Kenntnis der Codepage kommt man damit nicht weit.

128 lässt sich nach Windows-1251, Windows-1252 und ISO-8859-1 als "€" auflösen, 196 nach ISO-8859-1 als "Ä". Nach CP437 und CP850 kämen dann "├" und "Ç" raus. In Windows-1250 hättest du "Д" und "Ђ". Und so weiter.

Heißt: Um das richtig nach Unicode übersetzen zu können brauchst du die Information, welche 8-Bit-Codepage der Text hatte, BEVOR er in UTF-8 konvertiert wurde.

[Uwe Raabe]

Zitat:

Zitat von Schokohase (Beitrag 1437596)

Ich weiß nicht warum, aber mit dem Code bekomme ich bei Delphi 10.3.2 nur Fehler

Das kommt davon, wenn man vergisst, den korrigierten Code auch einzufügen. Die jetzige Version sollte funktionieren.