Base64.pas und Delphi2009

**emsländer**

Moin,

Delphi2009 und Base64.pas beissen sich. Da ich jetzt ziemlich in der Luft hänge und Eile geboten ist, hier meine Frage, ob einer von den Cracks hier, der mit D2009 arbeitet, diese base64.pas anpassen kann?

Die Fehlermeldungen seht ihr in der Anlage

hier die base64.pas

zusammenfalten · markieren

Delphi-Quellcode:

			{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 

* 

* Unit Name : uBase64Codec 

* Author    : Daniel Wischnewski 

* Copyright : Copyright © 2001-2003 by gate(n)etwork GmbH. All Rights Reserved. 

* Creator   : Daniel Wischnewski 

* Contact   : Daniel Wischnewski (e-mail: delphi3000(at)wischnewski.tv); 

* 

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *} 

//                               * * * License * * * 

// 

// The contents of this file are used with permission, subject to the Mozilla 

// Public License Version 1.1 (the "License"); you may not use this file except 

// in compliance with the License. You may obtain a copy of the License at 

// 

//                       [url]http://www.mozilla.org/MPL/MPL-1.1.html[/url] 

// 

// Software distributed under the License is distributed on an "AS IS" basis, 

// WITHOUT WARRANTY OF ANY KIND, either express or  implied. See the License for 

// the specific language governing rights and limitations under the License. 

// 

//                               * * * My Wish * * * 

// 

// If you come to use this unit for your work, I would like to know about it. 

// Drop me an e-mail and let me know how it worked out for you. If you wish, you 

// can send me a copy of your work. No obligations! 

// My e-mail address: delphi3000(at)wischnewski.tv 

// 

//                               * * * History * * * 

// 

// Version 1.0 (Oct-10 2002) 

//    first published on Delphi-PRAXiS ([url]www.delphipraxis.net[/url]) 

// 

// Version 1.1 (May-13 2003) 

//    introduced a compiler switch (SpeedDecode) to switch between a faster 

//    decoding variant (prior version) and a litte less fast, but secure variant 

//    to work around bad formatted data (decoding only!) 

//    

// Version 1.2 (Juni-09 2004) 

//    included compiler switch {$0+}. In Delphi 6 and 7 projects using this code 

//    with compiler optimizations turned off will raise an access violation 

//    {$O+} will ensure that this unit runs with compiler optimizations. 

//    This option does *not* influence other parts of the project including this 

//    unit. 

//    Thanks to Ralf Manschewski for pointing out this problem. 

// 

unit Base64; 

{$O+} 

interface 

// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 

// !! THE COMPILER SWITCH MAY BE USED TO ADJUST THE BEHAVIOR !! 

// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 

// enable "SpeedDecode" 

//     the switch to gain speed while decoding the message, however, the codec 

//     will raise different exceptions/access violations or invalid output if 

//     the incoming data is invalid or missized. 

// disable "SpeedDecode" 

//     the switch to enable a data check, that will scan the data to decode to 

//     be valid. This method is to be used if you cannot guarantee to validity 

//     of the data to be decoded. 

{.DEFINE SpeedDecode} 

{$IFNDEF SpeedDecode} 

  {$DEFINE ValidityCheck} 

{$ENDIF} 

uses SysUtils; 

  // codiert einen String in die zugehörige Base64-Darstellung 

  function Base64Encode(const InText: AnsiString): AnsiString; overload; 

  // decodiert die Base64-Darstellung eines Strings in den zugehörigen String 

  function Base64Decode(const InText: AnsiString): AnsiString; overload; 

  // bestimmt die Größe der Base64-Darstellung 

  function CalcEncodedSize(InSize: Cardinal): Cardinal; 

  // bestimmt die Größe der binären Darstellung 

  function CalcDecodedSize(const InBuffer; InSize: Cardinal): Cardinal; 

  // codiert einen Buffer in die zugehörige Base64-Darstellung 

  procedure Base64Encode(const InBuffer; InSize: Cardinal; var OutBuffer); overload; register; 

  // decodiert die Base64-Darstellung in einen Buffer 

  {$IFDEF SpeedDecode} 

    procedure Base64Decode(const InBuffer; InSize: Cardinal; var OutBuffer); overload; register; 

  {$ENDIF} 

  {$IFDEF ValidityCheck} 

    function Base64Decode(const InBuffer; InSize: Cardinal; var OutBuffer): Boolean; overload; register; 

  {$ENDIF} 

  // codiert einen String in die zugehörige Base64-Darstellung 

  procedure Base64Encode(const InText: PAnsiChar; var OutText: PAnsiChar); overload; 

  // decodiert die Base64-Darstellung eines Strings in den zugehörigen String 

  procedure Base64Decode(const InText: PAnsiChar; var OutText: PAnsiChar); overload; 

  // codiert einen String in die zugehörige Base64-Darstellung 

  procedure Base64Encode(const InText: AnsiString; var OutText: AnsiString); overload; 

  // decodiert die Base64-Darstellung eines Strings in den zugehörigen String 

  procedure Base64Decode(const InText: AnsiString; var OutText: AnsiString); overload; 

implementation 

const 

  cBase64Codec: array[0..63] of AnsiChar = 

    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; 

  Base64Filler = '='; 

function Base64Encode(const InText: string): string; overload; 

begin 

  Base64Encode(InText, Result); 

end; 

function Base64Decode(const InText: string): string; overload; 

begin 

  Base64Decode(InText, Result); 

end; 

function CalcEncodedSize(InSize: Cardinal): Cardinal; 

begin 

  // no buffers passed along, calculate outbuffer size needed 

  Result := (InSize div 3) shl 2; 

  if ((InSize mod 3) > 0) 

  then Inc(Result, 4); 

end; 

function CalcDecodedSize(const InBuffer; InSize: Cardinal): Cardinal; 

type 

  BA = array of Byte; 

begin 

  Result := 0; 

  if InSize = 0 then 

    Exit; 

  if InSize mod 4 <> 0 then 

    Exit; 

  Result := InSize div 4 * 3; 

  if (BA(InBuffer)[InSize - 2] = Ord(Base64Filler)) 

  then Dec(Result, 2) 

  else if BA(InBuffer)[InSize - 1] = Ord(Base64Filler) 

       then Dec(Result); 

end; 

procedure Base64Encode(const InBuffer; InSize: Cardinal; var OutBuffer 

    ); register; 

var 

  ByThrees, LeftOver: Cardinal; 

  // reset in- and outbytes positions 

asm 

  // load addresses for source and destination 

  // PBYTE(InBuffer); 

  mov  ESI, [EAX] 

  // PBYTE(OutBuffer); 

  mov  EDI, [ECX] 

  // ByThrees := InSize div 3; 

  // LeftOver := InSize mod 3; 

  // load InSize (stored in EBX) 

  mov  EAX, EBX 

  // load 3 

  mov  ECX, $03 

  // clear upper 32 bits 

  xor  EDX, EDX 

  // divide by ECX 

  div  ECX 

  // save result 

  mov  ByThrees, EAX 

  // save remainder 

  mov  LeftOver, EDX 

  // load addresses 

  lea  ECX, cBase64Codec[0] 

  // while I < ByThrees do 

  // begin 

  xor  EAX, EAX 

  xor  EBX, EBX 

  xor  EDX, EDX 

  cmp  ByThrees, 0 

  jz   @@LeftOver 

  @@LoopStart: 

    // load the first two bytes of the source triplet 

    LODSW 

    // write Bits 0..5 to destination 

    mov  BL, AL 

    shr  BL, 2 

    mov  DL, BYTE PTR [ECX + EBX] 

    // save the Bits 12..15 for later use [1] 

    mov  BH, AH 

    and  BH, $0F 

    // save Bits 6..11 

    rol  AX, 4 

    and  AX, $3F 

    mov  DH, BYTE PTR [ECX + EAX] 

    mov  AX, DX 

    // store the first two bytes of the destination quadruple 

    STOSW 

    // laod last byte (Bits 16..23) of the source triplet 

    LODSB 

    // extend bits 12..15 [1] with Bits 16..17 and save them 

    mov  BL, AL 

    shr  BX, 6 

    mov  DL, BYTE PTR [ECX + EBX] 

    // save bits 18..23 

    and  AL, $3F 

    xor  AH, AH 

    mov  DH, BYTE PTR [ECX + EAX] 

    mov  AX, DX 

    // store the last two bytes of the destination quadruple 

    STOSW 

    dec  ByThrees 

  jnz  @@LoopStart 

  @@LeftOver: 

  // there are up to two more bytes to encode 

  cmp  LeftOver, 0 

  jz   @@Done 

  // clear result 

  xor  EAX, EAX 

  xor  EBX, EBX 

  xor  EDX, EDX 

  // get left over 1 

  LODSB 

  // load the first six bits 

  shl  AX, 6 

  mov  BL, AH 

  // save them 

  mov  DL, BYTE PTR [ECX + EBX] 

  // another byte ? 

  dec  LeftOver 

  jz   @@SaveOne 

  // save remaining two bits 

  shl  AX, 2 

  and  AH, $03 

  // get left over 2 

  LODSB 

  // load next 4 bits 

  shl  AX, 4 

  mov  BL, AH 

  // save all 6 bits 

  mov  DH, BYTE PTR [ECX + EBX] 

  shl  EDX, 16 

  // save last 4 bits 

  shr  AL, 2 

  mov  BL, AL 

  // save them 

  mov  DL, BYTE PTR [ECX + EBX] 

  // load base 64 'no more data flag' 

  mov  DH, Base64Filler 

  jmp  @@WriteLast4 

  @@SaveOne: 

  // adjust the last two bits 

  shr  AL, 2 

  mov  BL, AL 

  // save them 

  mov  DH, BYTE PTR [ECX + EBX] 

  shl  EDX, 16 

  // load base 64 'no more data flags' 

  mov  DH, Base64Filler 

  mov  DL, Base64Filler 

  // ignore jump, as jump reference is next line ! 

  // jmp  @@WriteLast4 

  @@WriteLast4: 

    // load and adjust result 

    mov  EAX, EDX 

    ror EAX, 16 

    // save it to destination 

    STOSD 

  @@Done: 

end; 

{$IFDEF SpeedDecode} 

  procedure Base64Decode(const InBuffer; InSize: Cardinal; var OutBuffer); 

      overload; register; 

{$ENDIF} 

{$IFDEF ValidityCheck} 

  function Base64Decode(const InBuffer; InSize: Cardinal; var OutBuffer): 

      Boolean; overload; register; 

{$ENDIF} 

const 

  {$IFDEF SpeedDecode} 

    cBase64Codec: array[0..127] of Byte = 

  {$ENDIF} 

  {$IFDEF ValidityCheck} 

    cBase64Codec: array[0..255] of Byte = 

  {$ENDIF} 

  ( 

    $FF, $FF, $FF, $FF, $FF, {005>} $FF, $FF, $FF, $FF, $FF, // 000..009 

    $FF, $FF, $FF, $FF, $FF, {015>} $FF, $FF, $FF, $FF, $FF, // 010..019 

    $FF, $FF, $FF, $FF, $FF, {025>} $FF, $FF, $FF, $FF, $FF, // 020..029 

    $FF, $FF, $FF, $FF, $FF, {035>} $FF, $FF, $FF, $FF, $FF, // 030..039 

    $FF, $FF, $FF, $3E, $FF, {045>} $FF, $FF, $3F, $34, $35, // 040..049 

    $36, $37, $38, $39, $3A, {055>} $3B, $3C, $3D, $FF, $FF, // 050..059 

    $FF, $FF, $FF, $FF, $FF, {065>} $00, $01, $02, $03, $04, // 060..069 

    $05, $06, $07, $08, $09, {075>} $0A, $0B, $0C, $0D, $0E, // 070..079 

    $0F, $10, $11, $12, $13, {085>} $14, $15, $16, $17, $18, // 080..089 

    $19, $FF, $FF, $FF, $FF, {095>} $FF, $FF, $1A, $1B, $1C, // 090..099 

    $1D, $1E, $1F, $20, $21, {105>} $22, $23, $24, $25, $26, // 100..109 

    $27, $28, $29, $2A, $2B, {115>} $2C, $2D, $2E, $2F, $30, // 110..119 

    $31, $32, $33, $FF, $FF, {125>} $FF, $FF, $FF            // 120..127 

    {$IFDEF ValidityCheck} 

                               {125>}              , $FF, $FF, // 128..129 

      $FF, $FF, $FF, $FF, $FF, {135>} $FF, $FF, $FF, $FF, $FF, // 130..139 

      $FF, $FF, $FF, $FF, $FF, {145>} $FF, $FF, $FF, $FF, $FF, // 140..149 

      $FF, $FF, $FF, $FF, $FF, {155>} $FF, $FF, $FF, $FF, $FF, // 150..159 

      $FF, $FF, $FF, $FF, $FF, {165>} $FF, $FF, $FF, $FF, $FF, // 160..169 

      $FF, $FF, $FF, $FF, $FF, {175>} $FF, $FF, $FF, $FF, $FF, // 170..179 

      $FF, $FF, $FF, $FF, $FF, {185>} $FF, $FF, $FF, $FF, $FF, // 180..189 

      $FF, $FF, $FF, $FF, $FF, {195>} $FF, $FF, $FF, $FF, $FF, // 190..199 

      $FF, $FF, $FF, $FF, $FF, {205>} $FF, $FF, $FF, $FF, $FF, // 200..209 

      $FF, $FF, $FF, $FF, $FF, {215>} $FF, $FF, $FF, $FF, $FF, // 210..219 

      $FF, $FF, $FF, $FF, $FF, {225>} $FF, $FF, $FF, $FF, $FF, // 220..229 

      $FF, $FF, $FF, $FF, $FF, {235>} $FF, $FF, $FF, $FF, $FF, // 230..239 

      $FF, $FF, $FF, $FF, $FF, {245>} $FF, $FF, $FF, $FF, $FF, // 240..249 

      $FF, $FF, $FF, $FF, $FF, {255>} $FF                      // 250..255 

    {$ENDIF} 

  ); 

asm 

  push EBX 

  mov  ESI, [EAX] 

  mov  EDI, [ECX] 

  {$IFDEF ValidityCheck} 

    mov  EAX, InSize 

    and  EAX, $03 

    cmp  EAX, $00 

    jz   @@DecodeStart 

    jmp  @@ErrorDone 

    @@DecodeStart: 

  {$ENDIF} 

  mov  EAX, InSize 

  shr  EAX, 2 

  jz   @@Done 

  lea  ECX, cBase64Codec[0] 

  xor  EBX, EBX 

  dec  EAX 

  jz   @@LeftOver 

  push EBP 

  mov  EBP, EAX 

  @@LoopStart: 

    // load four bytes into EAX 

    LODSD 

    // save them to EDX as AX is used to store results 

    mov  EDX, EAX 

    // get bits 0..5 

    mov  BL, DL 

    // decode 

    mov  AH, BYTE PTR [ECX + EBX] 

    {$IFDEF ValidityCheck} 

      // check valid code 

      cmp  AH, $FF 

      jz   @@ErrorDoneAndPopEBP 

    {$ENDIF} 

    // get bits 6..11 

    mov  BL, DH 

    // decode 

    mov  AL, BYTE PTR [ECX + EBX] 

    {$IFDEF ValidityCheck} 

      // check valid code 

      cmp  AL, $FF 

      jz   @@ErrorDoneAndPopEBP 

    {$ENDIF} 

    // align last 6 bits 

    shl  AL, 2 

    // get first 8 bits 

    ror  AX, 6 

    // store first byte 

    STOSB 

    // align remaining 4 bits 

    shr  AX, 12 

    // get next two bytes from source quad 

    shr  EDX, 16 

    // load bits 12..17 

    mov  BL, DL 

    // decode 

    mov  AH, BYTE PTR [ECX + EBX] 

    {$IFDEF ValidityCheck} 

      // check valid code 

      cmp  AH, $FF 

      jz   @@ErrorDoneAndPopEBP 

    {$ENDIF} 

    // align ... 

    shl  AH, 2 

    // ... and adjust 

    rol  AX, 4 

    // get last bits 18..23 

    mov  BL, DH 

    // decord 

    mov  BL, BYTE PTR [ECX + EBX] 

    {$IFDEF ValidityCheck} 

      // check valid code 

      cmp  BL, $FF 

      jz   @@ErrorDoneAndPopEBP 

    {$ENDIF} 

    // enter in destination word 

    or   AH, BL 

    // and store to destination 

    STOSW 

    // more coming ? 

    dec  EBP 

  jnz  @@LoopStart 

  pop  EBP 

  // no 

  // last four bytes are handled separately, as special checking is needed 

  // on the last two bytes (may be end of data signals '=' or '==') 

  @@LeftOver: 

  // get the last four bytes 

  LODSD 

  // save them to EDX as AX is used to store results 

  mov  EDX, EAX 

  // get bits 0..5 

  mov  BL, DL 

  // decode 

  mov  AH, BYTE PTR [ECX + EBX] 

  {$IFDEF ValidityCheck} 

    // check valid code 

    cmp  AH, $FF 

    jz   @@ErrorDone 

  {$ENDIF} 

  // get bits 6..11 

  mov  BL, DH 

  // decode 

  mov  AL, BYTE PTR [ECX + EBX] 

  {$IFDEF ValidityCheck} 

    // check valid code 

    cmp  AL, $FF 

    jz   @@ErrorDone 

  {$ENDIF} 

  // align last 6 bits 

  shl  AL, 2 

  // get first 8 bits 

  ror  AX, 6 

  // store first byte 

  STOSB 

  // get next two bytes from source quad 

  shr  EDX, 16 

  // check DL for "end of data signal" 

  cmp  DL, Base64Filler 

  jz   @@SuccessDone 

  // align remaining 4 bits 

  shr  AX, 12 

  // load bits 12..17 

  mov  BL, DL 

  // decode 

  mov  AH, BYTE PTR [ECX + EBX] 

  {$IFDEF ValidityCheck} 

    // check valid code 

    cmp  AH, $FF 

    jz   @@ErrorDone 

  {$ENDIF} 

  // align ... 

  shl  AH, 2 

  // ... and adjust 

  rol  AX, 4 

  // store second byte 

  STOSB 

  // check DH for "end of data signal" 

  cmp  DH, Base64Filler 

  jz   @@SuccessDone 

  // get last bits 18..23 

  mov  BL, DH 

  // decord 

  mov  BL, BYTE PTR [ECX + EBX] 

  {$IFDEF ValidityCheck} 

    // check valid code 

    cmp  BL, $FF 

    jz   @@ErrorDone 

  {$ENDIF} 

  // enter in destination word 

  or   AH, BL 

  // AH - AL for saving last byte 

  mov  AL, AH 

  // store third byte 

  STOSB 

  @@SuccessDone: 

  {$IFDEF ValidityCheck} 

    mov  Result, $01 

    jmp  @@Done 

    @@ErrorDoneAndPopEBP: 

    pop  EBP 

    @@ErrorDone: 

    mov  Result, $00 

  {$ENDIF} 

  @@Done: 

  pop  EBX 

end; 

procedure Base64Encode(const InText: PAnsiChar; var OutText: PAnsiChar); 

var 

  InSize, OutSize: Cardinal; 

begin 

  // get size of source 

  InSize := Length(InText); 

  // calculate size for destination 

  OutSize := CalcEncodedSize(InSize); 

  // reserve memory 

  OutText := StrAlloc(Succ(OutSize)); 

  OutText[OutSize] := #0; 

  // encode ! 

  Base64Encode(InText, InSize, OutText); 

end; 

procedure Base64Encode(const InText: AnsiString; var OutText: AnsiString); 

    overload; 

var 

  InSize, OutSize: Cardinal; 

  PIn, POut: Pointer; 

begin 

  // get size of source 

  InSize := Length(InText); 

  // calculate size for destination 

  OutSize := CalcEncodedSize(InSize); 

  // prepare string length to fit result data 

  SetLength(OutText, OutSize); 

  PIn := @InText[1]; 

  POut := @OutText[1]; 

  // encode ! 

  Base64Encode(PIn, InSize, POut); 

end; 

procedure Base64Decode(const InText: PAnsiChar; var OutText: PAnsiChar); 

    overload; 

var 

  InSize, OutSize: Cardinal; 

begin 

  // get size of source 

  InSize := Length(InText); 

  // calculate size for destination 

  OutSize := CalcDecodedSize(InText, InSize); 

  // reserve memory 

  OutText := StrAlloc(Succ(OutSize)); 

  OutText[OutSize] := #0; 

  // encode ! 

  {$IFDEF SpeedDecode} 

    Base64Decode(InText, InSize, OutText); 

  {$ENDIF} 

  {$IFDEF ValidityCheck} 

    if not Base64Decode(InText, InSize, OutText) then 

      OutText[0] := #0; 

  {$ENDIF} 

end; 

procedure Base64Decode(const InText: AnsiString; var OutText: AnsiString); 

    overload; 

var 

  InSize, OutSize: Cardinal; 

  PIn, POut: Pointer; 

begin 

  // get size of source 

  InSize := Length(InText); 

  // calculate size for destination 

  PIn := @InText[1]; 

  OutSize := CalcDecodedSize(PIn, InSize); 

  // prepare string length to fit result data 

  SetLength(OutText, OutSize); 

  FillChar(OutText[1], OutSize, '.'); 

  POut := @OutText[1]; 

  // encode ! 

  {$IFDEF SpeedDecode} 

    Base64Decode(PIn, InSize, POut); 

  {$ENDIF} 

  {$IFDEF ValidityCheck} 

    if not Base64Decode(PIn, InSize, POut) then 

      SetLength(OutText, 0); 

  {$ENDIF} 

end; 

end.

Vielen Dank im Voraus

EL

**mkinzler**

StrAlloc scheint nicht unicodefähig zu sein.
Versuch mal einen expliziten Cast

**emsländer**

Zitat von mkinzler:

StrAlloc scheint nicht unicodefähig zu sein.
Versuch mal einen expliziten Cast

äh - weiss jetzt nicht, was Du meinst ...

Gruss

EL

**mkinzler**

OutText := PChar(StrAlloc(Succ(OutSize));

**emsländer**

Zitat von mkinzler:

OutText := PChar(StrAlloc(Succ(OutSize));

Das wars leider nicht. Bekomme die gleichen Fehlermeldungen

Gruss

EL

**mkinzler**

http://www.delphipraxis.net/internal...=402475#402475

**jbg**

Zitat von mkinzler:

StrAlloc scheint nicht unicodefähig zu sein.

Gerade das Gegenteil ist Fall. StrAlloc liefert einen PChar zurück, was in Delphi 2009 ein PWideChar ist. Und der ist nicht kompatibel zu einem PAnsiChar. Statt dem StrAlloc kann man aber das neue AnsiStrAlloc einsetzen.

Zitat:

Versuch mal einen expliziten Cast

Das gibt dann aber einen richtigen Datenschrott.

@emsländer: Man kann mehrere Fehlermeldungen in Delphi markieren und dann Ctrl+C drücken. Das macht das ganze etwas einfacher als ein Screenshot

Zitat:

markieren

Delphi-Quellcode:

			function Base64Encode(const InText: string): string; overload;

function Base64Decode(const InText: string): string; overload;

Im Interface-Teil wurden die beiden Funktionen auf AnsiString angepasst. Im implementation-Teil steht da aber noch string, was ein UnicodeString ist.

**emsländer**

Zitat von jbg:

Zitat von mkinzler:

StrAlloc scheint nicht unicodefähig zu sein.

Gerade das Gegenteil ist Fall. StrAlloc liefert einen PChar zurück, was in Delphi 2009 ein PWideChar ist. Und der ist nicht kompatibel zu einem PAnsiChar. Statt dem StrAlloc kann man aber das neue AnsiStrAlloc einsetzen.

Zitat:

Versuch mal einen expliziten Cast

Das gibt dann aber einen richtigen Datenschrott.

@emsländer: Man kann mehrere Fehlermeldungen in Delphi markieren und dann Ctrl+C drücken. Das macht das ganze etwas einfacher als ein Screenshot

Zitat:

markieren

Delphi-Quellcode:

			function Base64Encode(const InText: string): string; overload;

function Base64Decode(const InText: string): string; overload;

Im Interface-Teil wurden die beiden Funktionen auf AnsiString angepasst. Im implementation-Teil steht da aber noch string, was ein UnicodeString ist.

Was soll ich denn nun ändern? Ansistring zu string oder umgekehrt?

Gruss

EL

**mkinzler**

Zitat:

mkinzler hat folgendes geschrieben:
StrAlloc scheint nicht unicodefähig zu sein.

Gerade das Gegenteil ist Fall. StrAlloc liefert einen PChar zurück, was in Delphi 2009 ein PWideChar ist. Und der ist nicht kompatibel zu einem PAnsiChar. Statt dem StrAlloc kann man aber das neue AnsiStrAlloc einsetzen.

Sorry hatte übersehen, das OutText PAnsiChar ist

**emsländer**

Zitat von mkinzler:

Zitat:

mkinzler hat folgendes geschrieben:
StrAlloc scheint nicht unicodefähig zu sein.

Gerade das Gegenteil ist Fall. StrAlloc liefert einen PChar zurück, was in Delphi 2009 ein PWideChar ist. Und der ist nicht kompatibel zu einem PAnsiChar. Statt dem StrAlloc kann man aber das neue AnsiStrAlloc einsetzen.

Sorry hatte übersehen, das OutText PAnsiChar ist

Es ist geschafft!

Vielen Dank

Hoffe nur, das die Daten die rein- und rausgehen, die gleichen sind ....

Gruss

EL

Base64.pas und Delphi2009

Base64.pas und Delphi2009

Re: Base64.pas und Delphi2009

Re: Base64.pas und Delphi2009

Re: Base64.pas und Delphi2009

Re: Base64.pas und Delphi2009

Re: Base64.pas und Delphi2009

Re: Base64.pas und Delphi2009

Re: Base64.pas und Delphi2009

Re: Base64.pas und Delphi2009

Re: Base64.pas und Delphi2009

Forumregeln

mkinzler (Moderator) Registriert seit: 9. Dez 2005 Ort: Heilbronn 39.858 Beiträge Delphi 11 Alexandria	#2 Re: Base64.pas und Delphi2009 4. Jan 2009, 11:42 StrAlloc scheint nicht unicodefähig zu sein. Versuch mal einen expliziten Cast Markus Kinzler
	Zitat

emsländer Registriert seit: 21. Aug 2004 Ort: Lengerich 658 Beiträge RAD-Studio 2009 Ent	#3 Re: Base64.pas und Delphi2009 4. Jan 2009, 11:43 Zitat von mkinzler: StrAlloc scheint nicht unicodefähig zu sein. Versuch mal einen expliziten Cast äh - weiss jetzt nicht, was Du meinst ... Gruss EL Narben am Körper sind ein Zeichen dafür, das man gelebt hat. Narben auf der Seele sind ein Zeichen dafür, das man geliebt hat.
	Zitat

mkinzler (Moderator) Registriert seit: 9. Dez 2005 Ort: Heilbronn 39.858 Beiträge Delphi 11 Alexandria	#4 Re: Base64.pas und Delphi2009 4. Jan 2009, 11:47 OutText := PChar(StrAlloc(Succ(OutSize)); Markus Kinzler
	Zitat

emsländer Registriert seit: 21. Aug 2004 Ort: Lengerich 658 Beiträge RAD-Studio 2009 Ent	#5 Re: Base64.pas und Delphi2009 4. Jan 2009, 11:56 Zitat von mkinzler: OutText := PChar(StrAlloc(Succ(OutSize)); Das wars leider nicht. Bekomme die gleichen Fehlermeldungen Gruss EL Narben am Körper sind ein Zeichen dafür, das man gelebt hat. Narben auf der Seele sind ein Zeichen dafür, das man geliebt hat.
	Zitat

mkinzler (Moderator) Registriert seit: 9. Dez 2005 Ort: Heilbronn 39.858 Beiträge Delphi 11 Alexandria	#6 Re: Base64.pas und Delphi2009 4. Jan 2009, 12:00 http://www.delphipraxis.net/internal...=402475#402475 Markus Kinzler
	Zitat