Single-liner subroutine caller macro

Just a simple macro ("mcall") that enables labeled subroutines that expect up to four parameters in registers to be called in a single line. It will accept registers, quoted strings, values or memory references.
The example code is a complete program with example useage of some simple subroutines.

Code:

org 100h
 
macro mcall sub,arg1,arg2,arg3,arg4  
{
   local str

       if      arg1    eqtype ""                     ; quoted literal
            jmp     @F
          str     db      arg1,0,"$"
        @@:
             mov     eax,str
     else if arg1    eqtype 0 | arg1 eqtype eax      ; value or register      
           mov     eax,arg1
    else if arg1    eqtype [a]                      ; memory
            mov     eax,arg1
    end if

  if      arg2    eqtype ""                       
          jmp     @F
          str     db      arg2,0,"$"
        @@:
             mov     ebx,str
     else if arg2    eqtype 0 | arg2 eqtype eax    
              mov     ebx,arg2
    else if arg2    eqtype [a]
          mov     ebx,arg2
    end if

  if arg3 eqtype ""  
               jmp     @F
          str     db      arg3,0,"$"
        @@:
             mov     ecx,str
     else if arg3    eqtype 0 | arg3 eqtype eax 
         mov     ecx,arg3
    else if arg3    eqtype [a]
          mov     ecx,arg3
    end if

  if arg4 eqtype ""   
              jmp     @F
          str     db      arg4,0,"$"
        @@:
             mov     edx,str
     else if arg4    eqtype 0 | arg4 eqtype eax 
         mov             edx,arg4
    else if arg4    eqtype [a]
          mov     edx,arg4
    end if

  call sub
}

mcall szCopy,"Hello",temp
mcall  stdout,temp
mcall    stdout," World"
mov        ah,4ch
int   21h

temp db 20 dup(?)

szCopy: ; eax=source, ebx=dest
      mov     esi,eax
     mov     edi,ebx
     mov     edx,-1
 @@:
  inc     edx
 mov     al,byte[esi+edx]
    mov     byte[edi+edx],al
    cmp     al,0
        jne     @B
  mov     byte[edi+edx+1],0
   ret

stdout:  ; eax=source
        mov     esi,eax
     mov     edi,0
 @@:
   mov     al,byte[esi+edi]
    cmp     al,0
        je      @F
  mov     dl,al
       mov     ah,2
        int     21h
 inc     edi
 jmp     @B
 @@:       
       ret