Unicode Ersatz für Format

[himitsu]

dieses VInteger ist nur etwas irreführend :roll:

da ist einfach nur entweder der Dateninhalt oder ein Zeiger auf den Dateninhalt (z.B. bei String) des entsprechenden Parameters drin.

PS: schau mal nach "Variante offene Array-Parameter" oder einfach mal wie TVarRec definiert ist :zwinker:



was tatsächlich möglich ist, das bestimmt nur wvsprintf.

[xZise]

Also ich bekomme eine Menge Japanischer (oder irgendwas anderes Ostasiatisches) Zeichen.

[himitsu]

Kryptische Zeichen?

dann läuft was falsch ... wie sieht denn deine Funktion und der Aufruf aus?
diese Funktionen sind Unicode, also falls bei dir was mit ANSI ist, dann liegt es wohl daran.


wegen dem Int64:
diese Funktion kennt nichts über 32 Byte (bis auf Strings, wo die Zeiger aber auch 32-Bit sind)
konnte jedenfalls keine möglichen Paramerte für solche Datentypen entdecken.

hab hier aber mal den Parameter %q für einen 64-Bit-Integer eingeführt:

Delphi-Quellcode:

Function Format(S: WideString; Const Args: Array of Const): WideString;
  Var StrBuffer2: Array[0..1023] of WideChar;
    A: Array[0..15] of Integer;
    i, i2: Integer;
    i8: Int64;

  Begin
    // aufpassen!!! es wird eine unicodefähige StringReplace-Variante benötigt.
    S := StringReplace(S, '%q', '%d%09d', [rfReplaceAll]);
    i2 := 0;
    For i := 0 to High(Args) do
      If Args[i].VType = vtInt64 Then Begin
        i8 := Args[i].VInt64^;
        A[i2] := i8 div 1000000000;
        If i8 < 0 Then i8 := -i8;
        A[i2 + 1] := i8 mod 1000000000;
        Inc(i2, 2);
      End Else Begin
        A[i2] := Args[i].VInteger;
        Inc(i2);
      End;
    wvsprintfW(@StrBuffer2, PWideChar(S), @A);
    Result := PWideChar(@StrBuffer2);
  End;

procedure TForm1.FormCreate(Sender: TObject);
var i: int64;
begin
  i := 2345678901234567890;
  Caption := Format('%q %q', [1234567890123456789, i]);
end;

hier also nochmal die wichtigsten Parameter
%d integer
%q int64
%u cardinal
%s WideString
%S AnsiString/String
%x lower(hex)
%X upper(hex)

und der Ausgabestring darf maximal 1023 Zeichen lang sein.

für genauere Definitionen zu den Standardtypen siehe MSDN.

[xZise]

Der Aufruf sieht folgendermaßen aus:

Delphi-Quellcode:

MessageBoxW(hDPM, PWideChar(Format(_('Error while downloading and processing updateinformation.' + #13#10 + 'Message: %s' + #13#10 + 'Errorclass: %s'), [e.Message, e.ClassName])), PWideChar(_('[Update Plugin] Downloading/Processingerror')), MB_OK or MB_ICONERROR);

Selbst nativ (also ohne Übersetzung):

Zitat:

---------------------------
[Update Plugin] Downloading/Processingerror
---------------------------
Error while downloading and processing updateinformation.

Message: Ä
溡Ȇ

Errorclass: 䔉捸灥楴湯
---------------------------
OK
---------------------------

[Khabarakh]

e ist doch sicherlich eine stino Exception. Könnte es in diesem Falle vielleicht keine ganz so dumme Idee sein, einer Unicode-Funktion auch Unicode-String zu übergeben... ?

Delphi-Quellcode:

  Writeln(Format('Hello %s', ['World'])); // 'Hello ??d'
  Writeln(Format('Hello %S', ['World'])); // 'Hello World'
  Writeln(Format('Hello %s', [WideString('World')])); // 'Hello World'

[himitsu]

%s & %S ... siehe MSDN

in Deutsch:
%s = selber Stringtyp (Ansi/Wide), wie die Aufzurufende Funktion
%S = anderes Stringformat

also bei wvsprintfW %s für PWideChar/WideString und %S für P(Ansi)Char/(Ansi)String
und bei wvsprintf/wvsprintfA %s für P(Ansi)Char/(Ansi)String und %S für PWideChar/WideString

Delphi-Quellcode:

MessageBoxW(hDPM, PWideChar(Format('Error while downloading and processing updateinformation.'
  + #13#10'Message: %S'#13#10'Errorclass: %S', [e.Message, e.ClassName])),
  '[Update Plugin] Downloading/Processingerror', MB_OK or MB_ICONERROR);

// dieses _( ) macht 'ne Typenumwandlung, oder wie?
MessageBoxW(hDPM, PWideChar(Format('Error while downloading and processing updateinformation.'
  + #13#10'Message: %s'#13#10'Errorclass: %s', [_(e.Message), _(e.ClassName)])),
  '[Update Plugin] Downloading/Processingerror', MB_OK or MB_ICONERROR);

[turboPASCAL]

Ich hätte da noch eine kleine Frage, passt ja zum Thema.
wvsprintf kann nur Integer aber keine Floads oder ?

[himitsu]

nicht nur, aber keine reelen Typen

wenn man jetzt nicht auf die API versichtet und alles selbermachen will,
dann muß man entweder mit dem Fehlen einiger Formate leben, oder man muß versuchen den gewünschten Typen in die Grundtypen zu zerlegen (Bsp. siehe 1) oder muß diesen Typen selber z.B in einen String umwandeln (Bsp. siehe 2).
OK und man kann natürlich auch eine der vielen "fertigen" Unicodesammlungen verwenden. :angel:

1:

Delphi-Quellcode:

Function Format(S: WideString; Const Args: Array of Const): WideString;
  Var StrBuffer2: Array[0..1023] of WideChar;
    A: Array[0..15] of Integer;
    i, i2: Integer;
    i8: Int64;

  Begin
    // aufpassen!!! es wird eine unicodefähige StringReplace-Variante benötigt.
    S := StringReplace(S, '%q', '%d%09d', [rfReplaceAll]);
    S := StringReplace(S, '%F', '%d%09d,%09d', [rfReplaceAll]);
    i2 := 0;
    For i := 0 to High(Args) do
      Case Args[i].VType of
        vtInt64: Begin
          i8 := Args[i].VInt64^;
          A[i2] := i8 div 1000000000;
          If i8 < 0 Then i8 := -i8;
          A[i2 + 1] := i8 mod 1000000000;
          Inc(i2, 2);
        End;
        vtExtended: Begin
          i8 := Trunc(Args[i].VExtended^);
          A[i2] := i8 div 1000000000;
          If i8 < 0 Then i8 := -i8;
          A[i2 + 1] := i8 mod 1000000000;
          A[i2 + 2] := Trunc(Args[i].VExtended^ * 1000000000);
          Inc(i2, 3);
        End;
        Else Begin
          A[i2] := Args[i].VInteger;
          Inc(i2);
        End;
      End;
    wvsprintfW(@StrBuffer2, PWideChar(S), @A);
    Result := PWideChar(@StrBuffer2);
  End;

2:

Delphi-Quellcode:

Function Format(S: WideString; Const Args: Array of Const): WideString;
  Var StrBuffer2: Array[0..1023] of WideChar;
    A: Array[0..15] of Integer;
    T: Array[0..15] of String;
    i: Integer;

  Begin
    // aufpassen!!! es wird eine unicodefähige StringReplace-Variante benötigt.
    S := StringReplace(S, '%q', '%S', [rfReplaceAll]);
    S := StringReplace(S, '%f', '%S', [rfReplaceAll]);
    For i := High(Args) downto 0 do
      Case Args[i].VType of
        vtInt64: Begin
          T[i] := IntToStr(Args[i].VInt64^);
          A[i] := PChar(T[i]);
        End;
        vtExtended: Begin
          T[i] := FloatToStr(Args[i].VInt64^);
          A[i] := PChar(T[i]);
        End;
        Else A[i] := Args[i].VInteger;
      End;
    wvsprintfW(@StrBuffer2, PWideChar(S), @A);
    Result := PWideChar(@StrBuffer2);
  End;

[xZise]

Zitat:

Zitat von himitsu

in Deutsch:
%s = selber Stringtyp (Ansi/Wide), wie die Aufzurufende Funktion
%S = anderes Stringformat

Ah danke :)

Zitat:

Zitat von himitsu

Delphi-Quellcode:

MessageBoxW(hDPM, PWideChar(Format('Error while downloading and processing updateinformation.'
  + #13#10'Message: %S'#13#10'Errorclass: %S', [e.Message, e.ClassName])),
  '[Update Plugin] Downloading/Processingerror', MB_OK or MB_ICONERROR);

// dieses _( ) macht 'ne Typenumwandlung, oder wie?
MessageBoxW(hDPM, PWideChar(Format('Error while downloading and processing updateinformation.'
  + #13#10'Message: %s'#13#10'Errorclass: %s', [_(e.Message), _(e.ClassName)])),
  '[Update Plugin] Downloading/Processingerror', MB_OK or MB_ICONERROR);

Ersteres übersetzt den String nicht, und zweiteres ist etwas seltsam ;)
_() macht eine Übersetzung (siehe GnuGettext)

MfG
xZise

[himitsu]

asoooo, dacht schon des se wieder irgend so'n neues Delphifeature :lol:

dann natürlich so :angel:

Delphi-Quellcode:

MessageBoxW(hDPM, PWideChar(Format('Error while downloading and processing updateinformation.'
  + #13#10'Message: %S'#13#10'Errorclass: %S', [_(e.Message), _(e.ClassName_)])),
  '[Update Plugin] Downloading/Processingerror', MB_OK or MB_ICONERROR);

MessageBoxW(hDPM, PWideChar(Format('Error while downloading and processing updateinformation.'
  + #13#10'Message: %s'#13#10'Errorclass: %s', [WideString(_(e.Message)), WideString(_(e.ClassName_))])),
  '[Update Plugin] Downloading/Processingerror', MB_OK or MB_ICONERROR);