proc function [uses reg reg ...], argument1, argument2, ...    

proc function esp [uses reg reg ...], argument1, argument2, ...    

...
   match =params, params \{ params equ statement
                            flag = 0 \}
   match =esp any, params\{ params equ any
                            flag=flag+100b\}
   match =esp, params\{ params equ
                            flag=flag+100b\}
   match =uses reglist=,args, params \{ regs equ reglist
                                        params equ args \}
   match =regs =uses reglist, regs params \{ regs equ reglist
                                             params equ \}
   match =regs, regs \{ regs equ \}
   current = 4
   match y,regs\{irps x,y\\{ current=current+4 \\}\}
   if flag and 100b
    virtual at esp+current+localbytes
   else
    virtual at ebp+4+current
   end if
   match =,args, params \{ defargs@proc args \}
   match =args@proc args, args@proc params \{ defargs@proc args \}
   parmbytes = $-$$
   end virtual
...
   macro locals
   \{
    if flag and 100b
      virtual at esp+current
    else
      virtual at ebp-localbytes+current
    end if
      macro label . \\{ deflocal@proc .,:, \\}
...
      restruc rb,rw,rp,rd,rt,rq
      current = current + $-$$
      end virtual \}
...    

macro prologuedef procname,flag,parmbytes,localbytes,reglist
 {
   irps reg, reglist \{ push reg \}
   if ~(flag and 100b) & (parmbytes | localbytes)
    push ebp
    mov ebp,esp
   end if
   if localbytes
    add esp,-localbytes
   end if
}    

macro epiloguedef procname,flag,parmbytes,localbytes,reglist
 {
   if (flag and 100b) & localbytes
    sub esp,-localbytes
   end if
   if ~(flag and 100b) & (parmbytes | localbytes)
    leave
   end if
   irps reg, reglist \{ reverse pop reg \}
   if flag and 10000b
    retn
   else
    retn parmbytes
   end if }    

proc console_print esp,buff,length
        invoke  GetStdHandle,STD_OUTPUT_HANDLE
        push    ecx                     ;now we are in trouble!
        mov     ecx,esp
;the following invoke is VERY ugly now
        invoke  WriteFile,eax,[buff+16],[length+12],ecx,0
        pop     ecx                     ;back to normal stack again
        sub     eax,1                   ;carry=1=failed
        sbb     eax,eax
        or      eax,ecx                 ;-1=failed, other=successfully wrote eax bytes
        ret
endp    

proc crc32_byte_raw esp,crc,bite,polynomial
    ;this routine is very basic and using an EBP base is unnecessary
        mov     eax,[crc]
        not     eax
        xor     al,byte[bite]
        mov     edx,8
    .a: shr     eax,1
        sbb     ecx,ecx
        and     ecx,[polynomial]
        xor     eax,ecx
        dec     edx
        jnz     .a
        not     eax
        ret
endp    

I wish to see invoke, stdcall, and all that working without doing adjustments by my own. Do you think that it's possible or there is some limitation here that prevents automatic stack address adjustment?

1) The extra register makes some alogrithms really fly. 
2) Leaf procedures, or simple functions, that don't require the extra overhead of EBP base setup, saves code size and execution time.    

both are things that should be done by hand, and then they are done better than with macros, when it is really important

if used crc32_byte_raw
  crc32_byte_raw:
  virtual at esp
   .ret         dd ?
   .crc         dd ?
   .bite        dd ?
   .polynomial  dd ?
  end virtual
        mov     eax,[.crc]
        not     eax
        xor     al,byte[.bite]
        mov     edx,8
    .a: shr     eax,1
        sbb     ecx,ecx
        and     ecx,[.polynomial]
        xor     eax,ecx
        dec     edx
        jnz     .a
        not     eax
        ret
end if    

_internal_esp equ esp
esp equ ___undefined___symbol___

;and internally in your macros, you will use _internal_esp, user
;can't access esp directly. same for push/pop

restore _internal_esp
restore esp
    

maybe you could disable esp for that part of source, and enable it later:

proc a uses ebx
mov ebx, 123
push eax
ret
endp    

what problems does current proc macro have?

proc b uses ebx ,val
mov ebx, 123 
push eax 
ret 
endp    

;00401021    55              PUSH    EBP
;00401022    89E5            MOV     EBP,ESP
;00401024    53              PUSH    EBX
;00401025    BB 7B000000     MOV     EBX,7B
;0040102A    50              PUSH    EAX
;0040102B    5B              POP     EBX 
;0040102C    C9              LEAVE
;0040102D    C2 0400         RETN    4    

;00401021    53              PUSH    EBX
;00401022    55              PUSH    EBP
;00401023    89E5            MOV     EBP,ESP
;00401025    BB 7B000000     MOV     EBX,7B
;0040102A    50              PUSH    EAX
;0040102B    C9              LEAVE
;0040102C    5B              POP     EBX 
;0040102D    C2 0400         RETN    4    

;00401011    53              PUSH    EBX
;00401012    BB 7B000000     MOV     EBX,7B
;00401017    50              PUSH    EAX
;00401018    5B              POP     EBX
;00401019    C3              RETN    

btw, what was the reason of "uses ebx ecx" if this wasn't supported?

I'm sure Tomasz could make us proc macro using esp w/adjusting push/pop/call/invoke/stdcall etc.

proc abc esp uses ebx, foo
 ;...
 call .subFunction1
 call .subFunction2
 ;...
 ret
.subFunction1:
 mov eax,[foo] ;what offset goes here for foo?
 ;...
 retn
.subFunction2:
 mov eax,[foo] ;what offset goes here for foo?
 ;...
 call .subFunction1
 ;...
 retn
endp    

Petroizki (from MASM board) and me already made the same thing in MASM (called "pmacros"). I attach the latest help file which I'm aware of, maybe it can help you somehow.

Well, if it is missing a pop, then there is an error

proc abc uses ebx, foo
 ;...
 call .f1
 ;...
.err
 ret
.f1:
 invoke something,1,2,3
 test eax,eax
 jz .err
 ;...
 retn
endp    

proc abc uses ebx, foo
 ;...
 push ecx
 invoke something,1,2,3
 test eax,eax
 jz .err
 ;...
 pop ecx
 ;...
.err
 ret
endp