Escape sequenzen ersetzen

[manuel.taber]

Hallo,

kurze Schilderung meines Problems:

Ich erhalte von einem Windows - Dienst (in Python geschrieben) über UDP eine Zeichenkette, die ich in Delphi weiter verarbeiten möchte. Um übertragungsprobleme zu vermeiden, wurden in der Zeichenkette die Sonderzeichen durch \x + Hex Wert ersetzt.

So ergibt z.B. 'äöü' die Zeichenkette '\xe4\xf6\xfc'.

Gibt es eine Möglichkeit, die originale Zeichenkette wiederherstellen?

Danke im voraus
Manuel

[BUG]

Ja, das sollte nicht so schwer sein.
Wie wird denn das Backslash selbst escapted?

[manuel.taber]

Das Backslash muss glaube ich nicht escaped werden, weil '\x' für das escapen hergenommen wird.
Ich kann mich aber auch irren...

[himitsu]

spontan würde ich \\ für \ vermuten ... halt der normale C-Style




und Zurück:

Zeichencode auslesen und nach '\x'+2xHex umwandeln, außer bei #0 = '\0' oder #10 = '\n' oder '\' = '\\' usw.

[manuel.taber]

Gibt es keinen Parser oder ähnliches, der das für mich erledigt?

[DeddyH]

Vielleicht denke ich zu simpel, aber wieso nicht StringReplace? Das ist vielleicht nicht die schnellste Möglichkeit, aber wenn der Ausgangsstring nicht allzu lang ist, sollte das doch kein Problem sein.

[BUG]

Wie wäre es wenn du den Parser schreiben würdest :mrgreen:

Ich würde das mit einem endlichen Zustandsautomaten angehen:

Delphi-Quellcode:

function unescape(const input: AnsiString): AnsiString;
var
  state: (stNormal, stExpectX, stHex1, stHex2);
  curLength, cur: integer;
  escaped: string[3];

  procedure normal; inline;
  begin
    state := stNormal;
    inc(curLength);
    result[curLength] := input[cur];
  end;

begin
  setLength(result, length(input));
  curLength := 0;
  state := stNormal;
  for cur := 1 to length(input) do
  begin
    case state of
      stNormal:
        if input[cur] <> '\'
          then normal
          else state := stExpectX;
      stExpectX:
        if input[cur] = 'x'
          then state := stHex1
          else normal;
      stHex1:
        if input[cur] in ['0'..'9', 'a'..'f', 'A'..'F'] then
        begin
          escaped := '$' + input[cur];
          state := stHex2;
        end else normal;
      stHex2:
        begin
          if input[cur] in ['0'..'9', 'a'..'f', 'A'..'F']
            then escaped := escaped + input[cur]
            else state := stNormal;
          inc(curLength);
          result[curLength] := Chr(StrToInt(escaped));
          if state = stNormal
            then normal
            else state := stNormal;
        end;
    end;
  end;
  setLength(result, curLength);
end;

Nicht getestet, aber das Prinzip sollte klar werden.

[gammatester]

Zuerst müssen doch einmal die genauen Kodierungsregeln bekannt sein. Wie wird denn z.B.diese Original-Zeichenkette kodiert?

Code:

'äöü' wird als '\xe4\xf6\xfc' codiert!

Bei der Rückgewinnung sollte dann doch nicht herauskommen:

Code:

'äöü' wird als 'äöü' codiert!

[BUG]

Zitat:

Zitat von gammatester (Beitrag 1119608)

Zuerst müssen doch einmal die genauen Kodierungsregeln bekannt sein.

Deswegen habe ich ja gefragt, wie '\' codiert wird.
Wenn das Prinzip klar ist, kann man aus stExpectX ein stExcpectModifier (oder so) machen und '\n', '\0' und andere ähnlich behandeln.

EDIT:
Ich habe den Code mal getestet und verbessert.
Wer mit Lazarus testet, sollte die Ausgabe besser mit AnsiToUtf8 behandeln.

[Sherlock]

Ich kram das hier mal aus der Versenkung, weil das fast auf mein Gegenwärtiges Problem zutrifft: Datenquelle ist ein Python YAML. Ich erhalte escapete Unicodestrings wie zum Beispiel 'Gl\xF6ckner' an Stelle von 'Glöckner'. YAML ist nix anderes als hübscheres JSON (überspitzt gesagt, ich nutze YAML eigentlich nur, weil es einen Datumstypen kennt, was unter Python ein Segen ist, da kennt JSON nämlich [Standardkonform] keinen). Zurück zu meinem Problem: Was hier geschildert wurde ist ein Eigenbau, den ich von einem "Web" und "IoT" affinen Konstrukt wie Delphi in der Reinkarnation Seattle als eingebaut angesehen hätte. Ich finde aber nicht wirklich etwas hilfreiches. Es gibt Vorschläge TJSONObject.ParseJSONValue zu verwenden. Das scheitert daran, daß mein YAML eben kein JSON ist, denke ich. Zumindest bleibt das JSON Objekt leer, nach dem Parsen des Strings.

Edith fand heraus, daß ParseJSONValue daran scheitert, daß \x nicht vorgesehen ist sondern nur \u...

Sherlock

[Sherlock]

OK, es hat jetzt doch ein versöhnliches Ende genommen. Ich mache folgendes bei der Auswertung der empfangenen Strings:

Delphi-Quellcode:

myJSONValue := TJSONObject.ParseJSONValue(StringReplace(temp, '\x', '\u00', []));

Das klappt brauchbar.

Sherlock
- der schon mal den Bagger bestellt, damit dieser Thread wieder eingegraben werden kann.

[Photoner]

Was ist deine Frage?

Magst du was hilfreiches von uns sehen?

Zum Bsp. mit Rekursion:

Delphi-Quellcode:

 // <XYZ> wird ersetzt durch WideChar(XYZ) wenn zum einen die Kombination "<" + "XYZ" + ">" gefunden wird und zum anderen sich "XYZ" in einen Integer umwandeln lässt.
  function ParseLiteralsW(AInputString : WideString) : WideString;

      function WideStrCopy(ASourceString : WideString; AIndex : Cardinal; ALength : Cardinal) : WideString;
      var
        len   : Cardinal;
        indx  : Cardinal;
      begin
        len:=Length(ASourceString);
        if (AIndex>len) or (ALength=0) then 
        begin
          Result := '';
          exit;
        end;
        if AIndex=0 then indx:=1
        else indx:=AIndex;
        if (indx+ALength) > len then 
        begin
          SetLength(Result,len-indx+1);
          Move(ASourceString[indx],Result[1],(len-indx+1)*SizeOf(WideChar));        
        end else begin
          SetLength(Result,ALength);
          Move(ASourceString[indx],Result[1],(ALength)*SizeOf(WideChar));
        end;
      end;
  
      Function PosExW(SubStr: WideString; S: WideString; Offset : Longint = 1): LongInt;
      Begin
        if Length(SubStr)<=Length(S) then
        begin
          Result := Offset;
          While Length(SubStr) + Result - 1 <= Length(S) do
          Begin
            If CompareMem(@SubStr[1], @S[Result], Length(SubStr) shl 1) Then Exit;
            Inc(Result);
          End;
        End;
        Result := 0;
      End;

  var
    p1,p2   : Integer;
    tmpword : Word;
    tmpw    : WideString;
  begin
    Result:=AInputString;
    p1:=1;
    p2:=1;

    p1:= PosExW('<',AInputString,p1);
    p2:= PosExW('>',AInputString,p2);
    if (p1>0) and (p2>0) and (p2>p1+1) then begin
      Try 
        tmpword:=StrToInt(WideStrCopy(AInputString,p1+1,p2-p1-1));
        if (tmpword>0) and (tmpword<=MaxWord) then begin
          tmpw:=WideStrCopy(AInputString,1,p1-1)+WideChar(tmpword)+WideStrCopy(AInputString,p2+1,Length(AInputString)-p2);
          Result := ParseLiteralsW(tmpw);
        end;
      except

      End;
    end;
  end;

Zwischenzeitlich kam noch mal dein Beitrag, bis ich einen Fehler gefunden habe. Gut dass es bei dir klappt. Schönes Wochenende!

[Sherlock]

Danke für den Code, über kurz oder lang werde ich wohl darauf zurückkommen müssen, je komplexer meine Kommunikation zwischen Server und Client wird. Also vergebens ist das auf keinen Fall gewesen! Danke!

Sherlock

[Photoner]

Es ist immer noch ein Fehler in meinem Beitrag weiter oben. Die Sequenz <60>...<62> wird bei einem rekursiven Aufruf wieder geparsed. Unschön. Deswegen eine kleine Änderung:

Delphi-Quellcode:

  function ParseLiteralsW(AInputString : WideString) : WideString;
  var
    p1,p2   : Integer;
    tmpword : Word;
    tmpw    : WideString;
  begin
    Result:=AInputString;
    p1:=1;
    p2:=1;

    p1:= PosExW('<',AInputString,p1);
    p2:= PosExW('>',AInputString,p2);
    if (p1>0) and (p2>0) and (p2>p1+1) then begin
      Try
        tmpword:=StrToInt(WideStrCopy(AInputString,p1+1,p2-p1-1));
        if (tmpword>0) and (tmpword<=MaxWord) then begin                      //hier die Rekursion
          tmpw:=WideStrCopy(AInputString,1,p1-1)+WideChar(tmpword)+ ParseLiteralsW(WideStrCopy(AInputString,p2+1,Length(AInputString)-p2));
          Result := tmpw;
        end;
      except

      End;
    end;
  end;

[himitsu]

Was soll bitte dieses böse leere Except-End da im Code?
Und ja, ich weiß weshalb, aber halt warum, denn StrToIntDef oder TryStrToInt. :stupid:

PS: Versuch mal

Delphi-Quellcode:

abc<32>def<60>ghi

zu deescapen. :angle2:

Delphi-Quellcode:

p1:=1;
p2:=1;
p1:= PosExW('<',AInputString,p1);
p2:= PosExW('>',AInputString,p2);
if (p1>0) and (p2>0) and (p2>p1+1) then begin

kürzer

Delphi-Quellcode:

p1:= PosExW('<',AInputString,1);
p2:= PosExW('>',AInputString,1);
if (p1>0) and (p2>0) and (p2>p1+1) then begin

noch kürzer

Delphi-Quellcode:

p1:= PosW('<',AInputString);
p2:= PosW('>',AInputString);
if (p1>0) and (p2>0) and (p2>p1+1) then begin

aber eigentlich

Delphi-Quellcode:

p1:= PosW('<',AInputString);  // PosExW('<',AInputString,1);
p2:= PosExW('>',AInputString,p1{+1});
if (p1>0) and (p2>0) then begin

[Photoner]

Zitat:

Zitat von himitsu (Beitrag 1335273)

PS: Versuch mal

Delphi-Quellcode:

abc<32>def<60>ghi

zu deescapen. :angle2:

Ergebnis wie gewünscht: "abc def<ghi"

Die leere Exception bitte als imaginäres //TODO verstehen. Ich kommentiere nicht immer alle Baustellen. Schlechte Angewohnheit...
Sollte ich tatsächlich durch ein TryStrToInt ersetzen. Das ist deutlich besser.

Zitat:

Zitat von himitsu (Beitrag 1335273)

Delphi-Quellcode:

p1:= PosExW('<',AInputString,1);
p2:= PosExW('>',AInputString,1);
if (p1>0) and (p2>0) and (p2>p1+1) then begin

Das ist gekauft.

Delphi-Quellcode:

(p2>p1+1)

Sollte man testen; ein "<>" zu parsen ergibt keinen Sinn.
Du hast mich aber damit darauf aufmerksam gemacht, dass ich noch prüfen sollte ob vielleicht nach der "<>" Kombination noch ein "<XYZ>" folgt. Das wird verschluckt.

[Photoner]

Aller Guten Dinge sind drei:

Delphi-Quellcode:

  function ParseLiteralsW(AInputString : WideString) : WideString;
  var
    p1,p2   : Integer;
    tmpInt  : Integer;
    tmpw    : WideString;
  begin
    Result:=AInputString;

    p1:= PosExW('<',AInputString);
    p2:= PosExW('>',AInputString);
    if (p1>0) and (p2>0) and (p2>p1+1) then
    begin
      //Zweig: Mutmaßliche Escape Sequenz "<X>" vorhanden
      if TryStrToInt(WideStrCopy(AInputString,p1+1,p2-p1-1),tmpInt) then
      begin
        //Zweig: TryStrToInt liefert Integer
        if (tmpInt>=0) and (tmpInt<=MaxWord) then
        begin
          //Zweig: tmpInt liegt in gültigem Intervall
          tmpw:=WideStrCopy(AInputString,1,p1-1)+WideChar(tmpInt)+ ParseLiteralsW(WideStrCopy(AInputString,p2+1,Length(AInputString)-p2));
          Result := tmpw;
        end else
        begin
          //Zweig: tmpInt liegt nicht in gültigem Intervall  --> prüfe ob dahinter noch etwas geparsed werden soll
          tmpw:=WideStrCopy(AInputString,1,p2)+ParseLiteralsW(WideStrCopy(AInputString,p2+1,Length(AInputString)-p2));
          Result := tmpw;
        end;
      end else
      begin
        //Zweig: TryStrToInt liefert keinen Integer --> prüfe ob dahinter noch etwas geparsed werden soll
        tmpw:=WideStrCopy(AInputString,1,p2)+ParseLiteralsW(WideStrCopy(AInputString,p2+1,Length(AInputString)-p2));
        Result := tmpw;
      end;
    end else if (Length(AInputString)-p2>3) and (p2>0) and (p1>0) then
    begin
      //Zweig: Leere Sequenz "<>" --> prüfe ob dahinter noch etwas geparsed werden soll wenn noch mindestens 3 Zeichen danach kommen
      tmpw:=WideStrCopy(AInputString,1,p2)+ParseLiteralsW(WideStrCopy(AInputString,p2+1,Length(AInputString)-p2));
      Result := tmpw;
    end;
  end;

Eingabe: <><abc>abc<32>def<60>ghi<70000><>
Ausgabe: <><abc>abc def<ghi<70000><>

Jetzt habe ich hoffentlich alle Klarheiten beseitigt (-es ist etwas unübersichtlicher als vorher-) :thumb:

Danke für die Anregung!