.386
.model flat, stdcall

include msvcrt.inc
includelib msvcrt.lib
include kernel32.inc
includelib kernel32.lib
include masm32.inc
includelib masm32.lib

PutCh macro chr:VARARG
  FOR arg, <chr>
     mov byte ptr CHR, arg
     INVOKE StdOut, ADDR CHR
  ENDM
ENDM

_strcat Proto C dest:DWORD, src1:DWORD, src2:DWORD

.data
    CHR   db 0,0
    sir   db "\tp\tr\ti\tn\tt\tf\t \tt\te\ts\tt\t: sir1=""%s"", sir2=""%s""\nnr1=%h, nr2=%d, long=%li,\nchar='%c', pointer=%p", 0
    psir1 db "bla",0
    psir2 db "bla bla",0
    int1  dw 10000
    int2  dw -5555
    long  dd -1234567
    chr   db '*'

    abc db "ABCD",0
    efg db "LMNO",0
    alphabet db "asdfasgdgafgasg",0

.code
    start:

        ;push offset sir     ; 4
        ;movzx ax, chr
        ;push ax             ; 2
        ;push long           ; 4
        ;push word ptr int2  ; 2
        ;push word ptr int1  ; 2
        ;push offset psir2  ; 4
        ;push offset psir1   ; 4
        ;push offset sir     ; 4
        ;call _printf
        ;add esp, 26

        invoke _strcat, addr alphabet, addr abc, addr efg

        push offset alphabet
        call _printf
        add esp, 4

        call crt__getch
    exit:
        invoke ExitProcess, 0                 ; invoke ExitProcess API

_strcat Proc C uses ebx ecx edx dest:DWORD, src1:DWORD, src2:DWORD

    mov ebx, src1
    mov ecx, src2
    mov edx, dest

    sir1:

    mov al, BYTE ptr [ebx]
    cmp al, 0
    je sir2
    mov BYTE ptr [edx], al

    inc ebx
    inc edx

    jmp sir1

    sir2:

    xor ebx, ebx

    sir2_loop:

    mov al, BYTE ptr [ecx]
    mov BYTE ptr [edx], al
    cmp al, 0

    je done

    inc ecx
    inc edx

    jmp sir2_loop

    done:
    ret
_strcat EndP


_printf Proc
    push ebp
    mov  ebp, esp
    push esi
    push edi
    mov  edi, 12
    mov  esi, [ebp+8]                   ; ESI pointer la sir formatat
    dec  esi
  printf_loop:
    inc  esi
    mov  al, [esi]
    test al, al
    je printf_done
    cmp  al, '%'
    jne  printf_char
    inc  esi
    mov  al, [esi]
    cmp  al, 's'
    je   printf_param_str
    cmp  al, 'd'
    je   printf_param_int
    cmp  al, 'i'
    je   printf_param_int
    cmp  al, 'u'
    je   printf_param_uint
    cmp  al, 'h'
    je   printf_param_hex
    cmp  al, 'p'
    je   printf_param_ptr
    cmp  al, 'c'
    je   printf_param_char
    cmp  al, '%'
    je   printf_normal_char
    cmp  al, 'l'
    jne  printf_loop
    inc  esi
    mov  al, [esi]
    cmp  al, 'd'
    je   printf_param_long_int
    cmp  al, 'i'
    je   printf_param_long_int
    cmp  al, 'u'
    je   printf_param_long_uint
    cmp  al, 'h'
    je   printf_param_long_hex
    jmp  printf_loop
  printf_char:
    cmp al, '\'
    jne printf_normal_char
    inc esi
    mov al, [esi]
    cmp al, 'n'
    je  printf_crlf
    cmp al, 't'
    je printf_tab
    cmp al, '\'
    jne printf_loop
  printf_normal_char:
    PutCh al
    jmp  printf_loop
  printf_param_str:
    push dword ptr [ebp+edi]
    call crt__cputs
    add  esp, 4
    add  edi, 4
    jmp  printf_loop
  printf_param_int:
    movsx eax, word ptr [ebp+edi]
    push eax                            ; parametru PutI
    call _PutI                          ; Apel PutI "CDECL"
    add  esp, 4                         ; refacere stiva
    add  edi, 2                         ; doar 2 octeti pe stiva
    jmp printf_loop
  printf_param_uint:
    movzx eax, word ptr [ebp+edi]
    push eax                            ; parametru PutI
    call _PutU                          ; Apel PutU "CDECL"
    add  esp, 4                         ; refacere stiva
    add  edi, 2                         ; doar 2 octeti pe stiva
    jmp printf_loop
  printf_param_hex:
    PutCh '0', 'x'
    movzx eax, word ptr [ebp+edi]
    push eax                            ; parametru PutI
    call _PutH                          ; Apel PutU "CDECL"
    add  esp, 4                         ; refacere stiva
    add  edi, 2
    jmp printf_loop
 printf_param_char:
    mov al, byte ptr [ebp+edi]          ; citesc caracterul de pe stiva
    PutCh al                            ; Afisez
    add  edi, 2                         ; Eliberez stiva (2 octeti)
    jmp printf_loop
 printf_param_long_int:
    pushd [ebp+edi]
    call _PutI
    add  esp, 4                         ; refacere stiva parametru PutI
    add  edi, 4                         ; 4 octeti pe stiva
    jmp printf_loop
  printf_param_long_uint:
    pushd [ebp+edi]
    call _PutU
    add  esp, 4                         ; refacere stiva parametru PutI
    add  edi, 4                         ; 4 octeti pe stiva
    jmp printf_loop
  printf_param_long_hex:
    PutCh '0', 'x'
    pushd [ebp+edi]
    call _PutH
    add  esp, 4                         ; refacere stiva parametru PutI
    add  edi, 4                         ; 4 octeti pe stiva
    jmp printf_loop
  printf_param_ptr:
    pushd [ebp+edi]
    call _PutH
    add  esp, 4                         ; refacere stiva parametru PutI
    add  edi, 4                         ; 4 octeti pe stiva
    jmp printf_loop
  printf_crlf:
    PutCh 10,13
    jmp printf_loop
  printf_tab:
    .data
        spatii db "        ",0
    .code
        invoke StdOut, addr spatii
    jmp printf_loop
  printf_done:
    pop  edi
    pop  esi
    pop  ebp
    Ret
_printf EndP

_PutU proc                  ; parametri: numarfara semn
    push ebp                ; salvare EBP
    mov  ebp, esp           ; Copiere ESP in EBP pentru acesarea param
    push edx                ; salvare registri utilizati
    push ebx

    mov  eax, [ebp+8]       ; EAX <- parametru din stiva
    xor  edx, edx           ; edx = 0
    mov  ebx, 10
    div  ebx                ; EDX:EAX / baza  (EAX=cat, EDX = rest)

    test eax, eax           ; EAX == 0 (conditia de iesire)
    je PutU_Done

    push edx                ; EDX (rest) -> stiva

    push eax                ; push catul (param 1)
    call _PutU              ; apel recursiv
    add  esp, 4

    pop  edx                ; EDX <- stiva
  PutU_Done:
    add  dl, '0'            ; conversie cifra din DL in caracter ASCII

    PutCh dl

    pop  ebx                ; refacere registri utilizati
    pop  edx
    pop  ebp
    Ret
_PutU EndP

_PutH proc                  ; parametri: numarfara semn
    push ebp                ; salvare EBP
    mov  ebp, esp           ; Copiere ESP in EBP pentru acesarea param
    push edx                ; salvare registri utilizati
    push ebx

    mov  eax, [ebp+8]       ; EAX <- parametru din stiva
    xor  edx, edx           ; edx = 0
    mov  ebx, 16
    div  ebx                ; EDX:EAX / baza  (EAX=cat, EDX = rest)

    test eax, eax           ; EAX == 0 (conditia de iesire)
    je PutH_Done

    push edx                ; EDX (rest) -> stiva

    push eax                ; push catul (param 1)
    call _PutH              ; apel recursiv
    add  esp, 4

    pop  edx                ; EDX <- stiva
  PutH_Done:
    cmp  dl, 10             ; compar cifra cu 10
    jb  PutH_Cifra09        ; daca este mai mica = cifra zecimala (0-9)
    add  dl, ('A'-10)-'0' ;
  PutH_Cifra09:
    add  dl, '0'            ; conversie cifra din DL in caracter ASCII

    PutCh dl                ; refacere stiva

    pop  ebx                ; refacere registri utilizati
    pop  edx
    pop  ebp
    Ret
_PutH EndP

_PutI proc                  ; parametri: numar cu semn
    push ebp                ; salvare EBP
    mov  ebp, esp           ; Copiere ESP in EBP pentru acesarea param

    mov  eax, [ebp+8]       ; EAX <- parametru din stiva
    cmp  eax, 0
    jge  PutI_Pozitiv       ; salt daca param 1 este pozitiv

    PutCh '-'               ; afisare '-'
    mov  eax, [ebp+8]       ; reincarc EAX (midificat de afisare '-')
    neg  eax                ; inversez semnul (EAX devine pozitiv)

   PutI_Pozitiv:

    push eax
    call _PutU
    add  esp, 4

    pop  ebp
    Ret                 ; 2 pararametri DWORD pe stiva
_PutI EndP

end start