include 'win32ax.inc'

.data

  result  dd ?
  Caption db 'Result of eax',0


.code

  start:
        mov eax,'1'
        add eax,'2'
        mov [result],eax

        sub [result],48

        push MB_OK
        push Caption
        push result
        push NULL
        call [MessageBox]

        push 0
        call [ExitProcess]

.end start    

strFormat       db 'THE RESULT IS: %d',0
strTitle      db 'RESULT OF ADDITION',0
strBuffer        rb 64
...
mov     eax, 53627
add       eax, 73893
invoke    wsprintf, strBuffer, strFormat, eax
add      esp, 3*4

invoke  MessageBox, 0, strBuffer, strTitle, MB_OK
    

invoke  wsprintf, strBuffer, strFormat, eax
add     esp, 3*4    

cinvoke wsprintf, strBuffer, strFormat, eax ; Notice the leading c    

... Also, your code is responsible for cleaning the stack after the call.

ADD maybe ??? Also ZERO-terminate the string.

mov eax,'1' ;EAX = 31
add eax,'2' ;EAX = 31+32=63    

You need to convert the result from a register (say EAX) into a string, which can be shown in a dialog. It is done by a function wsprintf()....

include 'win32a.inc'
format PE console 4.0
entry start
;*********************************************
section '.data' data readable writeable
;*********************************************
v1      db '999999999999999999',0
v2       db '000099999999999999',0 ;must have same len as v1!!!
;          ^^^^                      <-left pad with zero's!!!
vv    db '0000000000000000000',0 ;<-vv must have len v1+1!!!
tit      db 'v1+v2='
x      dd 0
; v1+v2 =   1000099999999999998
;*********************************************
nl db 0
_s db '%s',13,0
_i db '%i',13,0
_x db '%08X ',13,0
;*********************************************
section '.text' code readable executable
;*********************************************
proc        strlen stdcall str:dword
xor     ecx,ecx
xor  eax,eax
mov  ebx,[str]
strlen_loop:
mov    al,byte[ebx]
cmp     al,0
jz      strlen_is_null_byte
inc      ecx
inc      ebx
jmp      strlen_loop
strlen_is_null_byte:
xor  eax,eax
mov  eax,ecx
ret
endp

;*********************************************
start:                      ;fasm_bn_add.fasm

stdcall strlen,v1              ;note: only v1's length is determined

mov   ecx,eax                 ;therefore v2 must have the same length
                             ;thus we would left pad v2 with zero's
xor  eax,eax
xor  ebx,ebx
add_digits:
xor       eax,eax
mov  ah,byte[v1+ecx-1]
add        al,byte[v2+ecx-1]
and        ax,$0f0f
mov bh,ah
add    bh,al
add    bh,bl                   ;bh=ah+al+carry(bl)
mov      byte[x],bl
mov       byte[x],bh
cmp       bh,10
jb     zero_carry              ;carry(bl)=1
mov     bl,1
sub     bh,10
jmp    past_zero_carry
zero_carry:
mov       bl,0
past_zero_carry:
or      bh,$30
mov   byte[vv+ecx],bh
dec  ecx
jnz      add_digits
cmp       bl,1
jb      no_final_carry
mov   byte[vv],$31
no_final_carry:

;*********************************************
; invoke  MessageBox,0,vv,tit,0
cinvoke printf,_s,vv;vv = 1000099999999999998
invoke  ExitProcess,0
;***********************************************
section '.idata' data import readable writeable
  library kernel32,'kernel32.dll',\
          user32,'user32.dll',\
          msvcrt,'msvcrt.dll'
  include 'api\kernel32.inc'
  include 'api\user32.inc'
  import msvcrt,\
         printf,'printf'
;***********************************************

    

So my question is, why was wsprintf implemented the way it was as opposed to other functions like StringCbPrintf, which appear to be a better (as in safer) way of doing things? I guess wsprintf was a general 'do-it-all' function whereas the others like StringCbPrintf are much more narrow in scope?