StrLCopy : Non VCL

[IronCobra]

Hallo,

hätte da mal eine Frage. Arbeite gerade an Non-VCL Projekten und muß StrLCopy benutzen. Da ich aber keine SysUtils nutzen will, hier meine Frage:

Gibt es die Möglichkeit StrLCopy als Non-VCL Funktion einzubinden? Und wenn ja welche verschiedenen Möglichkeiten gibt es?

Vielen Dank im voraus!!

[Rastaman]

Also ich hab mir die Funktion mal in der Delphi Hile angesehn, und in meinen Augen ist die Funktion
genau das gleiche wie die Copy-Funktion, und die ist in der Windows Unit enthalten.

[Luckie]

MSDN -> StrCpyN ;)

[IronCobra]

Luckie & ALL - danke für die Info .. aber wie benutzt man das genau (StrCpyN) um genau die Funktionen von StrLCopy zu gewährleisten? Danke

PS: Für StrCpyN benötige ich doch die Lightweight API, richtig? Oder kann man diese auch mit shellapi in den uses nutzen?

[Luckie]

Was ist die LightWeight API? Ich kenne nur eine Windows API zum Beispiel. Und deklariert sein dürfte es in der Windows.pas.

[IronCobra]

Wäre es nicht möglich einfach die StrLCopy Function aus der SysUtils in mein App einzubauen? Dadurch müßte nicht die ganze SysUtils genutzt werden, sondern nur StrLCopy - müßte doch funktionieren, oder?

Nur wenn ja, wo kann ich die Funktion finden für StrLCopy in den SysUtils? Danke!!

[Luckie]

Zitat:

Zitat von IronCobra

Nur wenn ja, wo kann ich die Funktion finden für StrLCopy in den SysUtils? Danke!!

In der SysUtils.pas?

[turboPASCAL]

Guckst Du Forensuche ? StrLCopy AND StrPCopy

[IronCobra]

Habs hinbekommen mit API ... lstrcpyn ... danke für die Tips

[SirThornberry]

anstelle von StrLCopy etc. kann man auch einfach move nehmen.

[hathor]

Delphi-Quellcode:

function StrLCopy(Dest, Source: PChar; MaxLen: Cardinal): PChar;
var
  Count: Cardinal;
begin
  // copies a specified maximum number of characters from Source to Dest
  Result := Dest;
  Count := 0;
  While (Count < MaxLen) and (Source^ <> #0) do begin
    Dest^ := Source^;
    Inc(Source);
    Inc(Dest);
    Inc(Count);
  end;
  Dest^ := #0;
end;

[himitsu]

Oder lstrcpyn (Unit Windows)

@hathor: Deine Funktion vergißt die abschließende #0 mitzuzählen.

Delphi-Quellcode:

/// <description> copies a specified maximum number of characters from Source to Dest </description>
function StrLCopy(Dest, Source: PChar; MaxLen: NativeUInt): PChar;
begin
  Dec(MaxLen);  // für die abschließende #0
  if NativeInt(MaxLen) < 0 then
    Exit(nil);
  Result := Dest;
  while (MaxLen > 0) and (Source^ <> #0) do begin
    Dest^ := Source^;
    Inc(Source);
    Inc(Dest);
    Dec(MaxLen);
  end;
  Dest^ := #0;
end;

[hathor]

Lazarus kennt NativeUInt und NativeInt nicht.

Geändert:

Dummerweise ist jetzt der String Firmware Rev kürzer - also ist meine Version richtig...
http://www.delphipraxis.net/1163962-post21.html

Delphi-Quellcode:

/// <description> copies a specified maximum number of characters from Source to Dest </description>
function StrLCopy(Dest, Source: PChar; MaxLen: UInt64): PChar;
begin
  Dec(MaxLen); // für die abschließende #0
  if Int64(MaxLen) < 0 then
    Exit(nil);
  Result := Dest;
  while (MaxLen > 0) and (Source^ <> #0) do begin
    Dest^ := Source^;
    Inc(Source);
    Inc(Dest);
    Dec(MaxLen);
  end;
  Dest^ := #0;
end;

[himitsu]

Wie nennt sich denn der echte "Integer" (dynamischer und potentieller 64-Bit-Integer) im Lazarus?

Kannst du mal mit lstrcpyn testen, was dabei raus kommt?

[hathor]

Übrigens: lstrcpyn function - MSDN schreibt:
Copies a specified number of characters from a source string into a buffer.
Warning Do not use.
Consider using StringCchCopy instead.

Bevor ich das mit LAZARUS testen kann (ist auf einem anderen Notebook) zeige ich mal den Code von der Borland Software Corporation:

Delphi-Quellcode:

function StrLCopy(Dest: PChar; const Source: PChar; MaxLen: Cardinal): PChar; assembler;
asm
        PUSH    EDI
        PUSH    ESI
        PUSH    EBX
        MOV     ESI,EAX
        MOV     EDI,EDX
        MOV     EBX,ECX
        XOR     AL,AL
        TEST    ECX,ECX
        JZ      @@1
        REPNE   SCASB
        JNE     @@1
        INC     ECX
@@1:    SUB     EBX,ECX
        MOV     EDI,ESI
        MOV     ESI,EDX
        MOV     EDX,EDI
        MOV     ECX,EBX
        SHR     ECX,2
        REP     MOVSD
        MOV     ECX,EBX
        AND     ECX,3
        REP     MOVSB
        STOSB
        MOV     EAX,EDX
        POP     EBX
        POP     ESI
        POP     EDI
end;

---------------
FPC currently uses 32 bits (4 bytes) for integers, whether the machine is a 32-bit or 64-bit machine. This will cause code expecting an integer and a pointer to be the same size to fail as a 64-bit machine uses 64-bit pointers. To allow you to write portable code, the FPC system unit introduces the types PtrInt and PtrUInt which are signed and unsigned integer data types with the same size as a pointer.
http://wiki.freepascal.org/Integer

[himitsu]

Och, die Hinweise für C++ (ala man sollte Makros wie StringCchCopy verwenden) ignoriere ich grundsätzlich. :angle2:


@hator: Tausch besser noch schnell das PChar durch PAnsiChar aus,
denn dieser Code ist definitiv nur für ANSI geeignet.


[add]
ASM > Pascal

Delphi-Quellcode:

function StrLCopy(Dest, Source: PAnsiChar; MaxLen: Cardinal): PAnsiChar;
var
  i: Cardinal;
begin
  if Byte(Dest) <> 0 then begin
    i := MaxLen;
    while Source^ <> #0 do begin
      Dest^ := Source^;
      Inc(Source);
      Inc(Dest);
      Dec(i);
    end;
    Inc(i);
  end;
  Dec(MaxLen, i);
  Source := Dest;   // hier hab ich wohl irgendwas falsch übersetzt (ich versuch's später nochmal) 
  Dest   := Result; //
  Result := Source; //
{****
  i := MaxLen shr 2;
  while i > 0 do begin
    PLongWord(Dest)^ := PLongWord(Source)^;
    Inc(Source, 4);
    Inc(Dest, 4);
    Dec(i);
  end;
  i := MaxLen and 3;
  while i > 0 do begin
    Dest^ := Source^;
    Inc(Source);
    Inc(Dest);
    Dec(i);
  end;
*****}
  while MaxLen > 0 do begin
    Dest^ := Source^;
    Inc(Source);
    Inc(Dest);
    Dec(MaxLen);
  end;
{*****}
  Dest^ := #0;
end;

[hathor]

Zitat:

Zitat von himitsu (Beitrag 1163978)

Kannst du mal mit lstrcpyn testen, was dabei raus kommt?

Bei der Firmware fehlt eine 1.
Das Array ist 8 Char gross - also sollten auch 8 Char zurückgegeben werden:
sFirmwareRevArray[0..7] of Char;

Ich verwende jetzt Move - das geht auch und FEHLERFREI!

Delphi-Quellcode:

procedure PrintIdSectorInfo( IdSector : TIdSector );
var szOutBuffer : Array [0..40] of Char;
begin
  with IdSector do
  begin
    ChangeByteOrder( sModelNumber, SizeOf(sModelNumber) ); // Change the WORD array to a BYTE array
    szOutBuffer[SizeOf(sModelNumber)] := #0;
//    StrLCopy( szOutBuffer, sModelNumber, SizeOf(sModelNumber) );
//    lstrcpyn( szOutBuffer, sModelNumber, SizeOf(sModelNumber) );
    System.Move(sModelNumber, szOutBuffer, SizeOf(sModelNumber) );
    Form1.label1.caption :='Model :                  ' + szOutBuffer ;

    ChangeByteOrder( sFirmwareRev, SizeOf(sFirmwareRev) );
    szOutBuffer[SizeOf(sFirmwareRev)] := #0;
//    StrLCopy( szOutBuffer, sFirmwareRev, SizeOf(sFirmwareRev) );
//    lstrcpyn( szOutBuffer, sFirmwareRev, SizeOf(sFirmwareRev) );
    System.Move(sFirmwareRev, szOutBuffer, SizeOf(sFirmwareRev) );
    Form1.label2.caption := 'Firmware Rev :         ' + szOutBuffer ;

    ChangeByteOrder( sSerialNumber, SizeOf(sSerialNumber) );
    szOutBuffer[SizeOf(sSerialNumber)] := #0;
 //   StrLCopy( szOutBuffer, sSerialNumber, SizeOf(sSerialNumber) );
 //   lstrcpyn(szOutBuffer, sSerialNumber, SizeOf(sSerialNumber) );
    System.Move(sSerialNumber, szOutBuffer, SizeOf(sSerialNumber) );
    Form1.label3.caption :=  'Serial Number :  '+ szOutBuffer ;
  end;
end;

http://www.delphipraxis.net/1163962-post21.html

[himitsu]

Zitat:

Das Array ist 8 Char gross - also sollten auch 8 Char zurückgegeben werden:
sFirmwareRevArray[0..7] of Char;

Falsch.
maximal 7 Chars + #0 :stupid: (also, wenn man auf PChar-Funktionen zurückgreift)

[hathor]

Als Teil eines Records entfällt #0.

[himitsu]

Zitat:

Zitat von hathor (Beitrag 1164067)

Als Teil eines Records entfällt #0.

Das wissen aber nicht diese Funktionen ... für die muß es immer mit einer #0 enden, da ausschließlich die #0 als Ende gilt.

Delphi-Quellcode:

lstrcpyn( szOutBuffer, sModelNumber, SizeOf(sModelNumber) + SizeOf(sModelNumber[0]) );

Nur der Zielpuffer muß natürluch groß genug sein.

[Luckie]

Hat das eigentlich noch irgendeinen praktischen Sinn oder macht ihr gerade einen Wettbewerb daraus? ;)

[hathor]

Nee, die Sache ist schon lange geklärt:

http://www.delphipraxis.net/379996-post10.html
http://www.delphipraxis.net/1164057-post17.html

himitsu versucht immer, eine "abschliessende 0" ins Spiel zu bringen, wo keine ist...

[himitsu]

z.B. #13, #15 und lstrcpyn haben nunmal diese #0 am Ende.