... but isn't there more easy way ?

g_value dd 1234    

g_buffer rb 256    

dec2str:
        ; EAX = value
        ; EDI = buffer
        mov     ecx,10
    .stack_dec:
        xor     edx,edx
        div     ecx
        add     edx,'0'
        push    edx
        test    eax,eax
        jz      .purge_dec
        call    .stack_dec
    .purge_dec:
        pop     dword[edi]
        inc     edi
        ret    

mov eax,[g_value]
mov edi,g_buffer
call dec2str
    

invoke MessageBox,0,g_buffer,0,0    

{
Base (var) = ecx
Number (var) = eax
div instruction in performs Unsigned division of edx:eax by
  r/m32 (ecx in out case), with result stored in
  eax = Quotient
  edx = Remainder
so
 Reminder (var) = edx
}

function Dec2Str(Number, Base: Integer):string;
var
 Reminder: Integer;
 i: Integer;
begin
 i := 1;
 while Number <> 0 do
 begin
  Reminder := Number mod Base;  //store the reminder of the division in Reminder = edx
  Number := Number div Base;    //eq. to "div ecx", in delphi 2 steps needs, no function for division and reminder at the same time
  Inc(Reminder, Ord('0'));     //eq. to " add edx, '0' ", add the POSITION of zero in the ascii table to each reminder to get its ASCII equivalent
  SetLength(Result, I);        //Delphi Stuff.....
  Result[i] := chr(Reminder);  //convert ASCII code to its Char equivalent
  Inc(i);                      //More Delphi Stuff.....
 end;
 Result := ReverseString(Result); //works the same way as " pop dword[edx] ", since stack follows LIFO, reversing is required
end;

//Usage:
// _String := Dec2Str(2588, 10);
    

proc fitoa num, string

    local buf: rb 10

    finit
    fild [num] ; load integer
    fbstp tword [buf] ; store packed bcd

    mov ecx,9 ; counter: 18 digits - 9 bytes
    mov edx,[string] ; pointer to the string to fill
    cmp [buf + ecx],0 ; if highest byte is not null - negative number
    je  @F
    mov byte [edx],"-" ; then set "-" at the string start
    inc edx
@@:    
    mov al,[buf + ecx - 1] ; get bytes in backward direction (higher bytes have higher address
    mov ah,al ; split packed bcd in al to two unpacked in al/ah
    shr al,4
    and ah,15
    add ax,3030h ; add 30h to each number to get ascii code
    mov [edx],ax ; store couple of digits into string
    inc edx ; get next string address
    inc edx
    loop @B ; get next offset in buf, if 0 - done
    mov [edx],cl ; set end of string 
    ret

endp