BIGINT.itoa:
      ; rsi = BIGINT pointer
      ; rcx = qword limbs in big integer
  ; rdi = string buffer

   mov rbp,5*5*5*5*5*5*5*5*5 * 5*5*5*5*5*5*5*5*5 * 5*5*5*5*5*5*5*5*5
   jmp .3
  .1:     xor edx,edx
 xor ebx,ebx
 push rcx
  .0:
       mov rax,[rsi+rcx*8]
 div rbp
     shrd rbx,rax,27+10
  shrd rax,rbx,27
     mov [rsi+rcx*8],rax
 dec ecx
     jns .0
      shl rbx,10
  shr rbx,27+10

   ; N mod 10^27 = RBP * RBX + RDX
     mov rax,rbx
 mov rbx,rdx
 mul rbp
     add rax,rbx
 adc rdx,0

       ; extract the 27 digits...

      pop rcx
  .2:    cmp qword [rsi+rcx*8],0
     jne .1
  .3:     dec ecx
     jns .2

  retn    

topofbuffer rd 1
.buffer rb 32
endofbuffer db 0
num:
.dec:
; eax = number to convert
        mov esi,endofbuffer
        dec esi
        mov ebx,10  ; decimal base
        mov ch,' '
        test eax,80000000h
        jne .positif
        neg eax    ;eax = |eax|
        mov ch,'-' ;set the minus sign
.positif:
.next:
        cdq         ; expand eax for the division ( xor edx,edx is ok)
        idiv ebx   ; divide by 10
        mov cl,dl   ;extract one digit from the remainder,
        add cl,'0'   
        mov [esi],cl  ;store digit, high digit first 
        dec esi         ;increment digit rank
        cmp eax,0    ; do it until eax = 0
        jne .next
        cmp ch,'-'     ;is it a negative number?
        je @f
        mov ch,cl
        inc esi
@@:
        mov [esi],ch
        mov [topofbuffer],esi
        ret
    

topofbuffer dd xxxxxxxxxx>>>> v
buffer      db 0,0,0,0,0,0,0,'-','1','2','3','4','5','6'
endofbuffer db 0
    

dword_to_string:
  ;eax    dword value
 ;edi    pointer to string buffer

        push    ebp
 mov     ebp,esp
     sub     esp,12
      and     esp,not 0xF
 mov     dword[esp],eax
      mov     dword[esp+4],0
      fild    qword[esp]
  mov     ecx,5
       fbstp   [esp]   ;store packed-BCD
     .loop1:
       sub     ecx,1
       mov     al,[esp+ecx]
        test    al,al
       jnz     .br_loop1
   test    ecx,ecx
     jnz     .loop1
      mov     byte[edi],'0'
     mov     byte[edi+1],0
       mov     esp,ebp
     pop     ebp
 ret
     .br_loop1:
  test    al,0xF0
     jnz     .loop2
      add     al,'0'
    stosb
       test    ecx,ecx
     jz      .end_loop
   sub     ecx,1
       mov     al,[esp+ecx]
     .loop2:
    mov     ah,al
       shr     al,4
        and     ah,0x0F
     add     al,'0'
    add     ah,'0'
    mov     byte[edi],al
        mov     byte[edi+1],ah
      add     edi,2
       test    ecx,ecx
     jz      .end_loop
   sub     ecx,1
       mov     al,[esp+ecx]
        jmp     .loop2
     .end_loop:
       mov     byte[edi],0
 mov     esp,ebp
     pop     ebp
 ret    

   push    -1
  mov     ebx,0cccccccdh
    .a:   mov     ecx,eax
     mul     ebx
 and     edx,-8
      mov     eax,edx
     sub     ecx,edx
     shr     edx,2
       sub     ecx,edx
     push    ecx
 shr     eax,3
       jnz     .a
  pop     eax
    .b:      add     al,'0'
    ;;;put your print/store function here. Example only shown in next line
              stosb ;example only!
        pop     eax
 test    al,10h
      jz      .b    

Funny how this type of stuff is so overly complex on an x86. Even the divide by '10' method.

I used to program at an insurance company and their IBM mainframe (I think zOS s/370) had built in numeric formatting. In ASM it was the ED opcode and you'd use EPDIC character mask like "$,$$$,ZZZ.ZZ".

An old school strictly business oriented processor would have that type of thing as part of the architecture and the x87 FPU only went as far as BCD. I guess the 'strictly business oriented' part answers my own non-question.

[If you read this far you won't be getting any return on your time ]

format PE64 GUI
entry start

include 'win64a.inc'

section '.text' code readable executable

start:

base=11
hexnumber=0xffffffffffffffff


        lea     rdi,[answer]
        mov     rcx,base
        mov     r10,hexnumber
        call    ConvertFromHex
        invoke MessageBox,NULL,answer,caption,MB_OK
        invoke ExitProcess,0



ConvertFromHex:
; rcx: base
; r10: number to convert
; rdi: address to write string to

        cld
        mov     rbp,rsp
        mov     rax,1
        xor     rdx,rdx
loop_push:
        mov     rbx,rax
        push    rbx
        mul     rcx
        jo      loop_pop
        cmp     rax,r10
        jb      loop_push
loop_pop:       
        xor     rdx,rdx
        pop     rcx
        mov     rax,r10
        div     rcx
        mov     al,[digit_table+rax]
        stosb
        mov     r10,rdx
        cmp     rbp,rsp
        jne     loop_pop
        mov     al,0
        stosb
        ret

section '.data' data readable writeable
  answer rb 65
  caption db 'Result:',0
  digit_table   db '0123456789abcdefghijklmnopqrstuvwxyz',0

section '.idata' import data readable writeable
  library kernel32,'KERNEL32.DLL',\
          user32,'USER32.DLL'

  include 'api\kernel32.inc'
  include 'api\user32.inc'         

r22 wrote:

An old school strictly business oriented processor would have that type of thing as part of the architecture and the x87 FPU only went as far as BCD. I guess the 'strictly business oriented' part answers my own non-question.

But the main problem is that is offers no flexibility. If you have a requirement that is even slightly different then you have go and code up the whole thing using other instructions. It is a waste of space in the microcode of the CPU unless you can be sure that it is used often.