CompToStr

[Nothine]

ich weiß nicht ob du bereits eine bessere lösung gefunden hast, aber ich hab mich in den letzten tagen mal etwas stärker mit dem thema comp auseinandergesetzt, und herausgekommen ist diese funktion(-sansammlung):

Delphi-Quellcode:

{ unterstützende Funktionen: }

const cwChop: Word = $1F32;

procedure Int;
asm
  SUB     ESP,$02
  FSTCW   WORD PTR [ESP]
  FWAIT
  FLDCW   cwChop
  FRNDINT
  FWAIT
  FLDCW   WORD PTR [ESP]
  ADD     ESP,$02
end;

function CompMod10(C: Comp): Byte;
const Ten: Integer = $0A;
asm
  ADD     ESP,-$04
  FILD    QWORD PTR [ESP+$0C]
  FIDIV   DWORD PTR [TEN]
  FST
  CALL    Int
  FSUBP
  FIMUL   DWORD PTR [TEN]
  FISTP   DWORD PTR [ESP]
  POP     EAX
  AND     EAX,$FF
  CMP     AL,$0A
  JB      @@End
  NEG     AL
@@End:
end;

function CompDivMod10(var C: Comp): Byte;
const Ten: Integer = $0A;
asm
  PUSH    DWORD PTR [EAX+$04] // bzw.:
  PUSH    DWORD PTR [EAX]     // 
  FILD    QWORD PTR [EAX]     // function CompDivMod10(...): Byte;
  FIDIV   DWORD PTR [TEN]     // begin
  CALL    Int                 //   Result := CompMod10(C);
  FISTP   QWORD PTR [EAX]     //   C := Int(C/10); // System.Int
  CALL    CompMod10           // end;
end;

function CompLen(C: Comp): Byte;
const Ten: Integer = $0A;
asm
  PUSH    EDX                    // bzw.:
  SUB     ESP,$02                //
  FSTCW   WORD PTR [ESP]         // function CompLen(...): Byte;
  FLDCW   WORD PTR [cwChop]      // begin
  BT      DWORD PTR [ESP+$12],31 //   Result := Byte(C < 0);
  SETB    DL                     //   repeat
@@Loop:                          //     Inc(Result);
  INC     DL                     //     C := Int(C / 10); // System.Int
  FILD    QWORD PTR [ESP+$0E]    //   until C = 0;
  FIDIV   DWORD PTR [TEN]        // end;
  FRNDINT
  FISTP   QWORD PTR [ESP+$0E]
  BSR     EAX,DWORD PTR [ESP+$12]
  JNZ     @@Loop
  BSR     EAX,DWORD PTR [ESP+$0E]
  JNZ     @@Loop
  MOVZX   EAX,DL
  FLDCW   WORD PTR [ESP]
  ADD     ESP,$02
  POP     EDX
end;

{ Die Hauptfunktion: }

function CompToStr(C: Comp): string;
var I: Integer;
begin
  SetLength(Result,CompLen(C));
  if C < 0 then Result[1] := '-';
  I := Length(Result);
  repeat
    Result[I] := Char( CompDivMod10(C) + 48);
    Dec(I);
  until C = 0;
end;

hab mir allerdings verkniffen 1000er-Trennzeichen einzubauen (ich find die sehn blöd aus )