macro OutputDigit {
      add  dl, 30h ; 30h = '0'
      mov  ah, 2
      int  21h }

ShowDec:
  cmp  eax, 10
  jb   skip
    xor  edx, edx ; edx = 0
    mov  ebx, 10 
    div  ebx
    push dx       ; save all the reminders untill eax >= 10
    call ShowDec
    pop  dx         
    OutputDigit   ; displays number from 0 to 9  that is in dl
    ret
    skip:
  mov  dl, al
  OutputDigit
  ret    

In my variant I am using recursion, but I want to use the code in a macro so recursion is no good.

org 100h

macro OutputDigit {
      add  dl, '0'  
      mov  ah, 2  
      int  21h }  

firstShowDec = 1
macro ShowDec {

if firstShowDec
    firstShowDec = 0

    push ..endShowDec
..ShowDec:
    xor  edx, edx ; edx = 0
    mov  ecx, 10
    div  ecx
    test eax, eax
    jz   ..print

    push dx       
    call ..ShowDec
    pop  dx

    ..print:
    OutputDigit   ; displays number from 0 to 9  that is in dl 
    ret 

..endShowDec:
else
  call ..ShowDec
end if
}

mov     eax, 12345678
ShowDec

mov     eax, 87654321
ShowDec

int $20    

org 100h

macro ShowDec { local nextDigit, showDigit, done
    push word -1
    nextDigit:
      xor  edx, edx ; edx = 0
      mov  ecx, 10
      div  ecx
      push dx
    test eax, eax
    jz   nextDigit

    pop  dx
    showDigit:
      add  dl, '0'
      mov  ah, 2   
      int  21h
      pop  dx
    jns  showDigit }

  mov     eax, 1234567890
  ShowDec
  ret    

macro ShowDec { local nextDigit, showDigit, done
    push -1
    mov  ecx, 10
    nextDigit:
      xor  edx, edx ; edx = 0
      div  ecx
      push dx
    test eax, eax
    jnz  nextDigit
    pop  dx
    showDigit:
      add  dl, '0'
      mov  ah, 2   
      int  21h
      pop  dx
    test dx, dx
    jns  showDigit }    

macro ShowDec { local nextDigit, showDigit, done
    xor ebx, ebx
    xor cx,cx
    mov bl, 10
    nextDigit:
      cdq
      div  ebx
      push dx
      inc cx
    test eax, eax
    jnz  nextDigit
    showDigit:
      pop  dx
      add  dl, '0'
      mov  ah, 2
      int  21h
    loopw showDigit }
    

macro ShowDec { local nextDigit, showDigit, done
    xor ebx, ebx
    xor cx,cx
    mov bl, 10
    nextDigit:
      xor edx,edx
      div  ebx
      push dx
      inc cx
    test eax, eax
    jnz  nextDigit
    showDigit:
      pop  ax
      add  al, '0'
      mov  ah, 0xe
      int  10h
    loopw showDigit }
    

    ; esi must point at the string buffer that will receive the base10 digits
    ; eax is the integer
    mov ecx, 01999999Ah
    mov edi, esi

   rep_loop:
    mov ebx, eax
    mul ecx
    mov eax, edx

    lea edx, [edx*4+edx]
    add ebx, '0'
    add edx, edx
    sub ebx, edx

    mov [esi], bl
    inc esi

    test eax, eax
    jne rep_loop

    mov eax, esi
    sub eax, edi


   reverse_digits:
    dec esi
    mov cl, [edi]
    mov dl, [esi]
    mov [esi], cl
    mov [edi], dl
    inc edi
    cmp edi, esi
    jb reverse_digits    

1. fill "ecx" with the MAGIC number 
2. set "ebx" to the value of the current input number
3. multiply "eax" with "ecx"; "eax" being the current input number
   this will yield "eax/10" in the register "edx"
   because of that MAGIC number's magic 
4. now we will set "eax" to "current input number"
   which effectively means we just "divided eax by 10"
5. next, we will multiply "edx" (not "eax") by 10
   this is what those "lea" and "add edx, edx" are all about
6. now we have in "edx" the number truncated to 10 boundary
   this means that, by subtracting we will get the last digit
   I used an "add ebx, '0'" before the subtraction -- it is ok
   it doesn't matter in which order you do it. That addition
   is just for ASCII stuff anyway
7. next we put that digit in "ebx" into the string
8. repeat from 2
9. ...    

input number: 951
eax = 951

1. ecx = 01999999Ah
2. ebx = 951 (eax, in fact)
3. multiply eax with MAGIC ecx, so edx = 951/10 = 95
4. eax = 95
5. edx = 950
6. digit = ebx - edx = 951 - 950 = 1 :wink:
7. ...

repeat

2. ebx = 95 (remember, step 4 above)
3. multiply eax with MAGIC ecx, so edx = 95/10 = 9
4. eax = 9
5. edx = 90
6. digit = ebx - edx = 95 - 90 = 5 :wink:
7. ...

repeat

2. ebx = 9
3. multiply eax with MAGIC ecx, so edx = 9/10 = 0
4. eax = 0
5. edx = 0
6. digit = ebx - edx = 9 - 0 = 9 :wink:
7. ...    

Simpler Code for Restricted Dividend
Integer division by a constant can be made faster if the range of the dividend is limited, which
removes a shift associated with most divisors. For example, for a divide by 10 operation, use the
following code if the dividend is less than 4000_0005h:
mov eax, dividend
mov edx, 01999999Ah
mul edx
mov quotient, edx

I used the windows scientific calculator to divide 1 0000 0000 h by A , and I got 19999999h , so I guess this is an easy way to get the magic number, just I don't know where the extra 1 comes from .. I guess because the result is something like 19999999.9999999 ... h

And with the todays high-speed/size tehnologies I am still wondering whitch one is better, optimising for speed, or for space...