Code7 (Ansi/Wide <> 7 Bit)

[himitsu]

So, ich hab hier mal 'ne Codierung in einem 7-Bit-Format,

wobei hier die unteren 7 Bit unverändert bleiben (bis auf das *) und der Rest ebenfalls in diesen 7-Bit-Bereich ähnlich wie bei UTF-8 eingelagert werden.



Es wurde speziell auf eine Kopatibilität zu ASCII, OEM und ANSI geachtet,
d.h. es ist egal von wo ein mit Code7 erstellter Parameter übergeben wird.

BatchFile, Verknüpfung...


Es entstehen bei der Codierung auch keine Steuerzeichen, welche z.B. in einer BatchFile zu Poblemen führen könnten.

Selbst Parameter im UnicodeFormat (gut für Dateinamen) sind kein Problem.

Delphi-Quellcode:

// Parameter erstellen 
Parameter := QuotedString(Encode7('irgendwas, z.B. mit äöü'));

// übergebenen Parameter auslesen
S := Decode7(ParamStr(1));

Delphi-Quellcode:

Function Encode7(Const S: WideString): String;
  Var i: Integer;
    X: Array[0..4] of Char;

  Begin
    SetLength(Result, Length(S));
    For i := Length(S) downto 1 do
      Case S[i] of
        '*': Begin
          Insert('*', Result, i + 1);
          Result[i] := '*';
        End;
        #$007F..#$03A1: Begin
          X[0] := Char($40 or (Word(S[i]) mod $1F));
          X[1] := Char($60 or (Word(S[i]) div $1F));
          X[2] := #0;
          If X[0] >= '^' Then Inc(Byte(X[0]));
          If X[1] >= '|' Then Inc(Byte(X[1]));
          Insert(String(X), Result, i + 1);
          Result[i] := '*';
        End;
        #$03A2..#$709D: Begin
          X[0] := Char($40 or ( Word(S[i])          mod $1F));
          X[1] := Char($40 or ((Word(S[i]) div $1F) mod $1F));
          X[2] := Char($60 or ( Word(S[i]) div $3C1));
          X[3] := #0;
          If X[0] >= '^' Then Inc(Byte(X[0]));
          If X[1] >= '^' Then Inc(Byte(X[1]));
          If X[2] >= '|' Then Inc(Byte(X[2]));
          Insert(String(X), Result, i + 1);
          Result[i] := '*';
        End;
        #$709E..#$FFFF: Begin
          X[0] := Char($40 or ( Word(S[i])           mod $1F));
          X[1] := Char($40 or ((Word(S[i]) div $1F)  mod $1F));
          X[2] := Char($40 or ((Word(S[i]) div $3C1) mod $1F));
          X[3] := Char($60 or ( Word(S[i]) div $745F));
          X[4] := #0;
          If X[0] >= '^' Then Inc(Byte(X[0]));
          If X[1] >= '^' Then Inc(Byte(X[1]));
          If X[2] >= '^' Then Inc(Byte(X[2]));
          If X[3] >= '|' Then Inc(Byte(X[3]));
          Insert(String(X), Result, i + 1);
          Result[i] := '*';
        End;
        Else Result[i] := Char(S[i]);
      End;
  End;

Function Decode7(Const S: String): WideString;
  Function X(C, D: Char): Word;
    Begin
      If C <= D Then Result := Word(C) and $1F
      Else Result := (Word(C) and $1F) - 1;
    End;

  Var i, i2: Integer;

  Begin
    SetLength(Result, Length(S));
    i := 1;  i2 := 1;
    While i <= Length(S) do
      If S[i] <> '*' Then Begin
        Result[i2] := WideChar(S[i]);
        Inc(i);  Inc(i2);
      End Else If (i < Length(S)) and (S[i + 1] = '*') Then Begin
        Result[i2] := '*';
        Inc(i, 2);  Inc(i2);
      End Else If (i < Length(S) - 1)
        and (Byte(S[i + 1]) and $E0 = $40)
        and (Byte(S[i + 2]) and $E0 = $60) Then Begin
        Result[i2] := WideChar(X(S[i + 1], '^')
          + (X(S[i + 2], '|') * $1F));
        Inc(i, 3);  Inc(i2);
      End Else If (i < Length(S) - 2)
        and (Byte(S[i + 1]) and $E0 = $40)
        and (Byte(S[i + 2]) and $E0 = $40)
        and (Byte(S[i + 3]) and $E0 = $60) Then Begin
        Result[i2] := WideChar(X(S[i + 1], '^')
          + (X(S[i + 2], '^') * $1F)
          + (X(S[i + 3], '|') * $3C1));
        Inc(i, 4);  Inc(i2);
      End Else If (i < Length(S) - 3)
        and (Byte(S[i + 1]) and $E0 = $40)
        and (Byte(S[i + 2]) and $E0 = $40)
        and (Byte(S[i + 3]) and $E0 = $40)
        and (Byte(S[i + 4]) and $E8 = $60) Then Begin
        Result[i2] := WideChar(X(S[i + 1], '^')
          + (X(S[i + 2], '^') * $1F)
          + (X(S[i + 3], '^') * $3C1)
          + (X(S[i + 4], '|') * $745F));
        Inc(i, 5);  Inc(i2);
      End Else Begin
        Result[i2] := '*';
        Inc(i);  Inc(i2);
      End;
    SetLength(Result, i2 - 1);
  End;

Eine Beispielanwendung versteckt sich als h-Sync, wenn dort ein nicht-ASCII/OEM-kompatibles Verzeichnis (z.B. mit äöü, oder Schlimmeren) ausgewählt ist.
> h-Sync > [Start] > [Jobs] > Params...

Delphi-Quellcode:

'n bißl unverwändlicher Kleinkram zum Code ._.

// 00101010 010***** 010***** 010***** 011*****
// 00101010 010***** 010***** 011*****
// 00101010 010***** 011*****
// 0*******

//        1F   40 60
// " 22   02
// < 3C   1C
// > 3E   1E
// ^ 5E   1E   5E
// | 7C   1C      7C
//  7F

[shmia]

Zitat:

Zitat von himitsu

So, ich hab hier mal 'ne Codierung in einem 7-Bit-Format

Handelt es sich hierbei um UTF-7 ?
Dann mein Vorschlag:

Delphi-Quellcode:

function StringToWideStringEx(const S: string; CodePage: Word): WideString;
var
  InputLength,
  OutputLength: Integer;
begin
  InputLength := Length(S);
  OutputLength := MultiByteToWideChar(CodePage, 0, PChar(S), InputLength, nil, 0);
  SetLength(Result, OutputLength);
  MultiByteToWideChar(CodePage, 0, PChar(S), InputLength, PWideChar(Result), OutputLength);
end;

function WideStringToStringEx(const WS: WideString; CodePage: Word): string;
var
  InputLength,
  OutputLength: Integer;
begin
  InputLength := Length(WS);
  OutputLength := WideCharToMultiByte(CodePage, 0, PWideChar(WS), InputLength, nil, 0, nil, nil);
  SetLength(Result, OutputLength);
  WideCharToMultiByte(CodePage, 0, PWideChar(WS), InputLength, PChar(Result), OutputLength, nil, nil);
end;


function UTF8ToWideString(const S: string): WideString;
begin
   Result := StringToWideStringEx(S, CP_UTF8);
end;
function WideStringToUTF8(const WS: WideString): string;
begin
   Result := WideStringToStringEx(WS, CP_UTF8);
end;
function UTF7ToWideString(const S: string): WideString;
begin
   Result := StringToWideStringEx(S, CP_UTF7);
end;
function WideStringToUTF7(const WS: WideString): string;
begin
   Result := WideStringToStringEx(WS, CP_UTF7);
end;

PS: beide Code-Varianten haben ihre Daseinsberechtigung. Meine Version läuft natürlich nur unter Win32.

[himitsu]

Nicht wirklich ... man könnte es wohl als eine Art Mischung aus URLEncode (PHP) und UTF-7 ansehen.

Bei URLEncode werden ja nur die zu codierende Zeichen über ein über ein bestimmtes Zeichen eingeführt (z.B. %, oder #), wärend die anderen Zeichen den alle möglichen Bits ausnutzen können.

Die UTF-Codierungen sind aber Aufgrund der dynamischen Länge der Codierten Zeichen nicht schlecht.


Als Efekt hat man dadurch ein schöne Lesbarkeit (fast vollständiger ASCII/OEM-Zeichensatz) und dennoch kurze Stringketten in den Kodierungen, welche auch nach oben offen sind.
Hier geht es bis 32-Bit (Unicode) und dennoch ist es möglich ohne Änderung der Code-Definition weiterzugehen (z.B. für spezielle Werte mit mehr als 32 Bit).


Zusätzlich wurde hier aber auch noch mit darauf geachtet, daß bei der Codierung bestimmte Zeichen nicht entstehen, wie z.B. " < > ^ | und  (#127), welche vorallem in Batchdateien zu netten Auswirkungen führen könnten.