Codierung/Decodierung von Umlauten

[mjustin]

Dieses Escaping wird auch für JSON verwendet (das J in JSON steht ja für JavaScript), daher kann man einen Umweg über einen JSON Parser nehmen.

Dazu würde man eine JSON Dokument "manuell" als einen JSON Ausdruck zusammensetzen in dem der betroffene Name mit \u.... Escape enthalten ist. Und dann diesen Ausdruck parsen und den Wert als Unicodestring abfragen.

Unter http://stackoverflow.com/a/4901205/80901 wird aber auch eine einfache Funktion zur Umwandlung gezeigt. Ist in JavaScript, dürfte aber leicht nach Delphi umsetzbar sein.

[Der schöne Günther]

Seit XE5(?) ist doch Json rundum dabei. So ware es spontan für einen String doch ok, oder?

Delphi-Quellcode:

uses
   System.SysUtils,
   System.Json; // Unter XE5 glaube ich Data.DBXJSON statt System.Json

procedure justEncodingThings();
const
   baseStrEnc: String = 'M\u00FCller';
   baseStrDec: String = 'Müller';
var
   decodedStr: String;
   jsonValue: TJSONValue;
begin
   jsonValue := TJSONObject.ParseJSONValue( baseStrEnc.QuotedString('"') );
   decodedStr := jsonValue.Value;

   Assert( decodedStr = baseStrDec );

   jsonValue.Free();
end;

[Sir Rufo]

Oder man klimpert sich das eben fix zusammen

Delphi-Quellcode:

unit JavaString;

interface

function JavaString_Decode( const AStr: string ): string;

implementation

uses
  System.SysUtils;

function OctalStrToInt( AOctal: string ): Integer;
var
  LChar: Char;
begin
  Result := 0;
  for LChar in AOctal do
    begin
      Result := Result * 8 + Ord( LChar ) - Ord( '0' );
    end;
end;

function JavaString_Decode( const AStr: string ): string;
var
  LTempBuffer: string;
  LChar: Char;
  LState: Integer;
  procedure Normal;
  begin
    case LChar of
      '\':
        LState := 1;
    else
      Result := Result + LChar;
    end;
  end;
  procedure Escape;
  begin
    case LChar of
      '\', '/', '"', '''':
        ;
      'b': // Backspace
        LChar := #$0008;
      't': // Horizontal Tab
        LChar := #$0009;
      'n': // New Line
        LChar := #$000A;
      'v': // Vertical Tab
        LChar := #$000B;
      'f': // Form Feed
        LChar := #$000C;
      'r': // Carriage Return
        LChar := #$000D;
      '0' .. '3': // Latin1 Octal
        begin
          LTempBuffer := LChar;
          LState := 2;
          Exit;
        end;
      'x': // Latin1 Hex
        begin
          LTempBuffer := '';
          LState := 3;
          Exit;
        end;
      'u': // Unicode Hex
        begin
          LTempBuffer := '';
          LState := 4;
          Exit;
        end;
    else
      raise EArgumentException.Create( 'Parse Error' );
    end;
    Result := Result + LChar;
    LState := 0;
  end;
  procedure Latin1Octal;
  var
    LByte: Byte;
  begin
    case LChar of
      '0' .. '7':
        LTempBuffer := LTempBuffer + LChar;
    else
      raise EArgumentException.Create( 'Parse Error' );
    end;
    if Length( LTempBuffer ) = 3
    then
      begin
        LByte := OctalStrToInt( LTempBuffer );
        Result := Result + TEncoding.Default.GetString( TArray<Byte>.Create( LByte ) );
        LState := 0;
      end;
  end;
  procedure Latin1Hex;
  var
    LByte: Byte;
  begin
    case LChar of
      '0' .. '9', 'A' .. 'F', 'a' .. 'f':
        LTempBuffer := LTempBuffer + LChar;
    else
      raise EArgumentException.Create( 'Parse Error' );
    end;
    if Length( LTempBuffer ) = 2
    then
      begin
        LByte := StrToInt( '$' + LTempBuffer );
        Result := Result + TEncoding.Default.GetString( TArray<Byte>.Create( LByte ) );
        LState := 0;
      end;
  end;
  procedure UnicodeHex;
  var
    LWord: Word;
  begin
    case LChar of
      '0' .. '9', 'A' .. 'F', 'a' .. 'f':
        LTempBuffer := LTempBuffer + LChar;
    else
      raise EArgumentException.Create( 'Parse Error' );
    end;
    if Length( LTempBuffer ) = 4
    then
      begin
        LWord := StrToInt( '$' + LTempBuffer );
        Result := Result + TEncoding.Unicode.GetString( TArray<Byte>.Create( Lo( LWord ), Hi( LWord ) ) );
        LState := 0;
      end;
  end;

begin
  Result := '';
  LState := 0;
  for LChar in AStr do
    case LState of
      0:
        Normal;
      1:
        Escape;
      2:
        Latin1Octal;
      3:
        Latin1Hex;
      4:
        UnicodeHex;
    end;
  if LState <> 0
  then
    raise EArgumentException.Create( 'Parse Error' );
end;

end.

Delphi-Quellcode:

procedure Main;
begin
  Writeln( JavaString_Decode( 'Copyright \251 \xA9 \u00A9' ) );
end;

ergibt dann

Code:

Copyright © © ©

[Der schöne Günther]

Bist du ein Zauberer?

[Sir Rufo]

Zitat von Der schöne Günther:

Bist du ein Zauberer?

Wieso? Die Konvention ist doch streng logisch und ich bin ganz stumpf danach vorgegangen (wie man auch am Quellcode sehen kann).

Ich hatte allerdings das \' unterschlagen

[himitsu]

Jupp, wenn man einmal weiß wie etwas im Grundprinzip funktioniert, dann kann man es
- entweder als State-Machine umsetzen
- oder in der Art des StringReplace (so hatte ich es schon im Kopf, aber keine Zeit/Lust es vorhin umzusetzen)
- man kann es auch gern als RegEx-Replace versuchen (ich glaub da hatte ich einen Code in Java/JavaScript/PHP gesehn)

Und für State-Machines gibt es sogar Generatoren, welche den Code generieren, wenn man ihnen die Konventionen nennt.

[Dejan Vu]

Na der Code ist schon ziemlich aufwändig. Die Statemachine muss man so nicht machen, eine einfache Fallunterscheidung und ein Lookupstring für die Literale reicht auch.

[himitsu]

Er umfasst ja auch die komplette Syntax, also nicht nur auf das \u bezogen, und das auch noch ganz "einfach" in Form einer State-Machine ("blind" übersetzt, ohne groß über das Ergebnis nachzudenken oder etwas zu "optimieren").

Man kann es auch locker in vielleicht 5-15 Zeilen zusammenfassen. (je nach dem was man von der Syntax alles implementiert)